Struct TapeLoop 

pub struct TapeLoop<T> { /* private fields */ }

Heap-allocated ring buffer for tape delay — single-threaded.

Unlike DelayLine, TapeLoop does NOT use const generics for its capacity — the buffer is allocated on the heap at runtime. This allows arbitrarily large delay lines (millions of samples) without stack overflow.

Thread safety

TapeLoop is not thread-safe. It uses plain T, not AtomicCell, because it is only accessed from the single audio thread.

Example

use rill_core::buffer::TapeLoop;

let mut tape = TapeLoop::<f32>::new(96000).unwrap();
tape.write(0.5);
let sample = tape.read(100);

Implementations

impl<T: Transcendental> TapeLoop<T>

pub fn new(capacity: usize) -> Option<Self>

Allocate a new tape loop with the given capacity (in samples).

pub fn capacity(&self) -> usize

Maximum capacity in samples.

pub fn write_pos(&self) -> usize

Current write cursor position.

pub fn write(&mut self, sample: T)

Write a single sample and advance the write cursor.

pub fn read(&self, delay: usize) -> T

Read a sample at delay samples behind the write position.

pub fn read_interpolated(&self, delay: f64) -> T

Read with linear interpolation between samples.

pub fn write_block(&mut self, block: &[T])

Write a full block of samples.

pub fn read_block(&self, delay: usize, output: &mut [T])

Read a full block starting at delay samples behind write position.

pub fn fill(&mut self, value: T)

Fill the entire buffer with a constant value.

pub fn clear(&mut self)

Reset write position and zero the buffer.

Trait Implementations

impl<T: Transcendental> Buffer<T> for TapeLoop<T>

fn len(&self) -> usize

Number of samples in the buffer.

fn as_slice(&self) -> &[T]

Read-only access to the buffer data.

fn as_mut_slice(&mut self) -> &mut [T]

Mutable access to the buffer data.

fn fill(&mut self, value: T)

where T: Copy,

Fill the entire buffer with a value.

fn copy_from(&mut self, src: &[T])

where T: Copy,

Copy data from a slice. Copies min(src.len(), self.len()) samples.

fn is_empty(&self) -> bool

Whether the buffer is empty.

impl<T: Debug> Debug for TapeLoop<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.