//! This module provides various helper functions for performing operations on slices of frames.
use ;
///// Conversion Functions
/////
///// The following functions wrap the various DSP slice conversion traits for convenience.
/// Converts the given slice into a slice of `Frame`s.
///
/// Returns `None` if the number of channels in a single frame `F` is not a multiple of the number
/// of samples in the given slice.
///
/// This is a convenience function that wraps the `ToFrameSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &[0.0, 0.5, 0.0, -0.5][..];
/// let bar = sample::slice::to_frame_slice(foo);
/// assert_eq!(bar, Some(&[[0.0, 0.5], [0.0, -0.5]][..]));
///
/// let foo = &[0.0, 0.5, 0.0][..];
/// let bar = sample::slice::to_frame_slice(foo);
/// assert_eq!(bar, None::<&[[f32; 2]]>);
/// }
/// ```
/// Converts the given mutable slice into a mutable slice of `Frame`s.
///
/// Returns `None` if the number of channels in a single frame `F` is not a multiple of the number
/// of samples in the given slice.
///
/// This is a convenience function that wraps the `ToFrameSliceMut` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &mut [0.0, 0.5, 0.0, -0.5][..];
/// let bar = sample::slice::to_frame_slice_mut(foo);
/// assert_eq!(bar, Some(&mut [[0.0, 0.5], [0.0, -0.5]][..]));
///
/// let foo = &mut [0.0, 0.5, 0.0][..];
/// let bar = sample::slice::to_frame_slice_mut(foo);
/// assert_eq!(bar, None::<&mut [[f32; 2]]>);
/// }
/// ```
/// Converts the given boxed slice into a boxed slice of `Frame`s.
///
/// Returns `None` if the number of channels in a single frame `F` is not a multiple of the number
/// of samples in the given slice.
///
/// This is a convenience function that wraps the `ToBoxedFrameSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = vec![0.0, 0.5, 0.0, -0.5].into_boxed_slice();
/// let bar: Box<[[f32; 2]]> = sample::slice::to_boxed_frame_slice(foo).unwrap();
/// assert_eq!(bar.into_vec(), vec![[0.0, 0.5], [0.0, -0.5]]);
///
/// let foo = vec![0.0, 0.5, 0.0].into_boxed_slice();
/// let bar = sample::slice::to_boxed_frame_slice(foo);
/// assert_eq!(bar, None::<Box<[[f32; 2]]>>);
/// }
/// ```
/// Converts the given slice into a slice of `Sample`s.
///
/// This is a convenience function that wraps the `ToSampleSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &[[0.0, 0.5], [0.0, -0.5]][..];
/// let bar = sample::slice::to_sample_slice(foo);
/// assert_eq!(bar, &[0.0, 0.5, 0.0, -0.5][..]);
/// }
/// ```
where
S: Sample,
T: ,
/// Converts the given mutable slice of `Frame`s into a mutable slice of `Sample`s.
///
/// This is a convenience function that wraps the `ToSampleSliceMut` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &mut [[0.0, 0.5], [0.0, -0.5]][..];
/// let bar = sample::slice::to_sample_slice_mut(foo);
/// assert_eq!(bar, &mut [0.0, 0.5, 0.0, -0.5][..]);
/// }
/// ```
where
S: Sample,
T: ,
/// Converts the given boxed slice into a boxed slice of `Sample`s.
///
/// This is a convenience function that wraps the `ToBoxedSampleSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = vec![[0.0, 0.5], [0.0, -0.5]].into_boxed_slice();
/// let bar = sample::slice::to_boxed_sample_slice(foo);
/// assert_eq!(bar.into_vec(), vec![0.0, 0.5, 0.0, -0.5]);
/// }
/// ```
/// Converts the given slice of `Sample`s into some slice `T`.
///
/// Returns `None` if the number of channels in a single frame is not a multiple of the number of
/// samples in the given slice.
///
/// This is a convenience function that wraps the `FromSampleSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &[0.0, 0.5, 0.0, -0.5][..];
/// let bar: Option<&_> = sample::slice::from_sample_slice(foo);
/// assert_eq!(bar, Some(&[[0.0, 0.5], [0.0, -0.5]][..]));
/// }
/// ```
/// Converts the given mutable slice of `Sample`s into some mutable slice `T`.
///
/// Returns `None` if the number of channels in a single frame is not a multiple of the number of
/// samples in the given slice.
///
/// This is a convenience function that wraps the `FromSampleSliceMut` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &mut [0.0, 0.5, 0.0, -0.5][..];
/// let bar: Option<&mut _> = sample::slice::from_sample_slice_mut(foo);
/// assert_eq!(bar, Some(&mut [[0.0, 0.5], [0.0, -0.5]][..]));
/// }
/// ```
/// Converts the given boxed slice of `Sample`s into some slice `T`.
///
/// Returns `None` if the number of channels in a single frame is not a multiple of the number of
/// samples in the given slice.
///
/// This is a convenience function that wraps the `FromBoxedSampleSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = vec![0.0, 0.5, 0.0, -0.5].into_boxed_slice();
/// let bar: Box<[[f32; 2]]> = sample::slice::from_boxed_sample_slice(foo).unwrap();
/// assert_eq!(bar.into_vec(), vec![[0.0, 0.5], [0.0, -0.5]]);
/// }
/// ```
/// Converts the given slice of `Frame`s into some slice `T`.
///
/// This is a convenience function that wraps the `FromFrameSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &[[0.0, 0.5], [0.0, -0.5]][..];
/// let bar: &[f32] = sample::slice::from_frame_slice(foo);
/// assert_eq!(bar, &[0.0, 0.5, 0.0, -0.5][..]);
/// }
/// ```
/// Converts the given slice of mutable `Frame`s into some mutable slice `T`.
///
/// This is a convenience function that wraps the `FromFrameSliceMut` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = &mut [[0.0, 0.5], [0.0, -0.5]][..];
/// let bar: &mut [f32] = sample::slice::from_frame_slice_mut(foo);
/// assert_eq!(bar, &mut [0.0, 0.5, 0.0, -0.5][..]);
/// }
/// ```
/// Converts the given boxed slice of `Frame`s into some slice `T`.
///
/// This is a convenience function that wraps the `FromBoxedFrameSlice` trait.
///
/// # Examples
///
/// ```
/// extern crate sample;
///
/// fn main() {
/// let foo = vec![[0.0, 0.5], [0.0, -0.5]].into_boxed_slice();
/// let bar: Box<[f32]> = sample::slice::from_boxed_frame_slice(foo);
/// assert_eq!(bar.into_vec(), vec![0.0, 0.5, 0.0, -0.5]);
/// }
/// ```
///// Utility Functions
/// Mutate every element in the slice with the given function.
/// Sets the slice of frames at the associated `Sample`'s equilibrium value.
/// Mutate every frame in slice `a` while reading from each frame in slice `b` in lock-step using
/// the given function.
///
/// **Panics** if the length of `b` is not equal to the length of `a`.
/// Writes every sample in slice `b` to slice `a`.
///
/// **Panics** if the slice lengths differ.
/// Adds every sample in slice `b` to every sample in slice `a` respectively.
/// Scale the amplitude of each frame in `b` by `amp_per_channel` before summing it onto `a`.
/// Mutate every element in slice `a` while reading from each element from slice `b` in lock-step
/// using the given function.
///
/// This function does not check that the slices are the same length and will crash horrifically on
/// index-out-of-bounds.
unsafe