Struct rotary::dynamic::Dynamic[][src]

pub struct Dynamic<T> { /* fields omitted */ }

A dynamically sized, multi-channel 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.

This kind of buffer stores each channel in its own heap-allocated slice of memory, meaning they can be manipulated more cheaply independently of each other than say Interleaved or Sequential. These would have to re-organize every constituent channel when resizing, while Dynamic generally only requires growing and shrinking of a memory region.

This kind of buffer is a good choice if you need to resize frequently.

Implementations

impl<T> Dynamic<T>[src]

pub fn new() -> Self[src]

Construct a new empty audio buffer.

Examples

let mut buffer = rotary::Dynamic::<f32>::new();

assert_eq!(buffer.frames(), 0);

pub fn with_topology(channels: usize, frames: usize) -> Self where
    T: Sample
[src]

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 mut buffer = rotary::Dynamic::<f32>::with_topology(4, 256);

assert_eq!(buffer.frames(), 256);
assert_eq!(buffer.channels(), 4);

pub fn from_array<const F: usize, const C: usize>(channels: [[T; F]; C]) -> Self where
    T: Copy
[src]

Allocate an audio buffer from a fixed-size array.

See dynamic!.

Examples

let mut buffer = rotary::Dynamic::<f32>::from_array([[2.0; 256]; 4]);

assert_eq!(buffer.frames(), 256);
assert_eq!(buffer.channels(), 4);

for chan in &buffer {
    assert_eq!(chan, vec![2.0; 256]);
}

pub fn from_frames<const N: usize>(frames: [T; N], channels: usize) -> Self where
    T: Copy
[src]

Allocate a dynamic audio buffer from a fixed-size array acting as a template for all the channels.

See dynamic!.

Examples

let mut buffer = rotary::Dynamic::from_frames([1.0, 2.0, 3.0, 4.0], 4);

assert_eq!(buffer.frames(), 4);
assert_eq!(buffer.channels(), 4);

pub fn frames(&self) -> usize[src]

Get the number of frames in the channels of an audio buffer.

Examples

let mut buffer = rotary::Dynamic::<f32>::new();

assert_eq!(buffer.frames(), 0);
buffer.resize(256);
assert_eq!(buffer.frames(), 256);

pub fn channels(&self) -> usize[src]

Check how many channels there are in the buffer.

Examples

let mut buffer = rotary::Dynamic::<f32>::new();

assert_eq!(buffer.channels(), 0);
buffer.resize_channels(2);
assert_eq!(buffer.channels(), 2);

pub fn iter(&self) -> Iter<'_, T>

Notable traits for Iter<'a, T>

impl<'a, T> Iterator for Iter<'a, T> type Item = &'a [T];
[src]

Construct a mutable iterator over all available channels.

Examples

use rand::Rng as _;

let mut buffer = rotary::Dynamic::<f32>::with_topology(4, 256);

let all_zeros = vec![0.0; 256];

for chan in buffer.iter() {
    assert_eq!(chan, &all_zeros[..]);
}

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Notable traits for IterMut<'a, T>

impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut [T];
[src]

Construct a mutable iterator over all available channels.

Examples

use rand::Rng as _;

let mut buffer = rotary::Dynamic::<f32>::with_topology(4, 256);
let mut rng = rand::thread_rng();

for chan in buffer.iter_mut() {
    rng.fill(chan);
}

pub fn resize(&mut self, frames: usize) where
    T: Sample
[src]

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 buffer = rotary::Dynamic::<f32>::new();

assert_eq!(buffer.channels(), 0);
assert_eq!(buffer.frames(), 0);

buffer.resize_channels(4);
buffer.resize(256);

assert_eq!(buffer[1][128], 0.0);
buffer[1][128] = 42.0;

assert_eq!(buffer.channels(), 4);
assert_eq!(buffer.frames(), 256);

Decreasing and increasing the size will not touch a buffer that has already been allocated.

assert_eq!(buffer[1][128], 0.0);
buffer[1][128] = 42.0;

buffer.resize(64);
assert!(buffer[1].get(128).is_none());

buffer.resize(256);
assert_eq!(buffer[1][128], 42.0);

pub fn resize_channels(&mut self, channels: usize) where
    T: Sample
[src]

Set the 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 buffer = rotary::Dynamic::<f32>::new();

assert_eq!(buffer.channels(), 0);
assert_eq!(buffer.frames(), 0);

buffer.resize_channels(4);
buffer.resize(256);

assert_eq!(buffer.channels(), 4);
assert_eq!(buffer.frames(), 256);

pub fn get(&self, channel: usize) -> Option<&[T]>[src]

Get a reference to the buffer of the given channel.

Examples

let mut buffer = rotary::Dynamic::<f32>::new();

buffer.resize_channels(4);
buffer.resize(256);

let expected = vec![0.0; 256];

assert_eq!(Some(&expected[..]), buffer.get(0));
assert_eq!(Some(&expected[..]), buffer.get(1));
assert_eq!(Some(&expected[..]), buffer.get(2));
assert_eq!(Some(&expected[..]), buffer.get(3));
assert_eq!(None, buffer.get(4));

pub fn get_or_default(&mut self, channel: usize) -> &[T] where
    T: Sample
[src]

Get the given channel or initialize the buffer with the default value.

Examples

let mut buffer = rotary::Dynamic::<f32>::new();

buffer.resize(256);

let expected = vec![0f32; 256];

assert_eq!(buffer.get_or_default(0), &expected[..]);
assert_eq!(buffer.get_or_default(1), &expected[..]);

assert_eq!(buffer.channels(), 2);

pub fn get_mut(&mut self, channel: usize) -> Option<&mut [T]>[src]

Get a mutable reference to the buffer of the given channel.

Examples

use rand::Rng as _;

let mut buffer = rotary::Dynamic::<f32>::new();

buffer.resize_channels(2);
buffer.resize(256);

let mut rng = rand::thread_rng();

if let Some(left) = buffer.get_mut(0) {
    rng.fill(left);
}

if let Some(right) = buffer.get_mut(1) {
    rng.fill(right);
}

pub fn get_or_default_mut(&mut self, channel: usize) -> &mut [T] where
    T: Sample
[src]

Get the given channel or initialize the buffer with the default value.

If a channel that is out of bound is queried, the buffer will be empty.

Examples

use rand::Rng as _;

let mut buffer = rotary::Dynamic::<f32>::new();

buffer.resize(256);

let mut rng = rand::thread_rng();

rng.fill(buffer.get_or_default_mut(0));
rng.fill(buffer.get_or_default_mut(1));

assert_eq!(buffer.channels(), 2);

pub fn into_vectors(self) -> Vec<Vec<T>>[src]

Convert into a vector of vectors.

This is provided for the Dynamic type because it’s a very cheap oepration due to its memory topology. No copying of the underlying buffers is necessary.

Examples

let mut buffer = rotary::Dynamic::<f32>::new();
buffer.resize_channels(4);
buffer.resize(512);

let expected = vec![0.0; 512];

let buffers = buffer.into_vectors();
assert_eq!(buffers.len(), 4);
assert_eq!(buffers[0], &expected[..]);
assert_eq!(buffers[1], &expected[..]);
assert_eq!(buffers[2], &expected[..]);
assert_eq!(buffers[3], &expected[..]);

pub fn into_vectors_if(
    self,
    condition: impl FnMut(usize) -> bool
) -> Vec<Vec<T>>
[src]

Convert into a vector of vectors using a condition.

This is provided for the Dynamic type because it’s a very cheap oepration due to its memory topology. No copying of the underlying buffers is necessary.

Channels which does not match the condition will be filled with an empty vector.

Examples

let mut buffer = rotary::Dynamic::<f32>::new();
buffer.resize_channels(4);
buffer.resize(512);

let expected = vec![0.0; 512];

let buffers = buffer.into_vectors_if(|n| n != 1);
assert_eq!(buffers.len(), 4);
assert_eq!(buffers[0], &expected[..]);
assert_eq!(buffers[1], &[][..]);
assert_eq!(buffers[2], &expected[..]);
assert_eq!(buffers[3], &expected[..]);

Trait Implementations

impl<T> Buf<T> for Dynamic<T>[src]

impl<T> BufMut<T> for Dynamic<T>[src]

impl<T> Debug for Dynamic<T> where
    T: Debug
[src]

impl<T> Drop for Dynamic<T>[src]

impl<T> Eq for Dynamic<T> where
    T: Eq
[src]

impl<T> ExactSizeBuf for Dynamic<T>[src]

impl<T, const F: usize, const C: usize> From<[[T; F]; C]> for Dynamic<T> where
    T: Copy
[src]

Allocate an audio buffer from a fixed-size array.

See dynamic!.

impl<T> Hash for Dynamic<T> where
    T: Hash
[src]

impl<T> Index<usize> for Dynamic<T>[src]

type Output = [T]

The returned type after indexing.

impl<T> IndexMut<usize> for Dynamic<T>[src]

impl<'a, T> IntoIterator for &'a Dynamic<T>[src]

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

impl<'a, T> IntoIterator for &'a mut Dynamic<T>[src]

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

impl<T> Ord for Dynamic<T> where
    T: Ord
[src]

impl<T> PartialEq<Dynamic<T>> for Dynamic<T> where
    T: PartialEq
[src]

impl<T> PartialOrd<Dynamic<T>> for Dynamic<T> where
    T: PartialOrd
[src]

impl<T> ResizableBuf for Dynamic<T> where
    T: Sample
[src]

impl<T> Send for Dynamic<T> where
    T: Send
[src]

impl<T> Sync for Dynamic<T> where
    T: Sync
[src]

Auto Trait Implementations

impl<T> RefUnwindSafe for Dynamic<T> where
    T: RefUnwindSafe

impl<T> Unpin for Dynamic<T>

impl<T> UnwindSafe for Dynamic<T> where
    T: RefUnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.