audio-processor-standalone

Provides a stand-alone audio-processor runner for AudioProcessor implementations.

```rust // Imports use std::time::Duration;

use audioprocessortraits::{AudioBuffer, AudioProcessor}; use circulardatastructures::CircularVec;

// Declare a delay audio_processor_traits::AudioProcessor implementation struct SimpleDelayProcessor { currentwriteposition: usize, currentreadposition: usize, delay_buffers: Vec>, }

impl SimpleDelayProcessor { fn new() -> Self { Self { currentwriteposition: (Duration::frommillis(800).assecsf32() * 44100.0) as usize, currentreadposition: 0, delaybuffers: vec![ CircularVec::withsize( (Duration::fromsecs(5).assecsf32() * 44100.0) as usize, 0.0, ), CircularVec::withsize( (Duration::fromsecs(5).assecsf32() * 44100.0) as usize, 0.0, ), ], } } }

impl AudioProcessor for SimpleDelayProcessor { type SampleType = f32;

fn process<BufferType: AudioBuffer<SampleType = Self::SampleType>>(
    &mut self,
    data: &mut BufferType,
) {
    // Mono input stage
    for sample_index in 0..data.num_samples() {
        data.set(0, sample_index, *data.get(1, sample_index));
    }

    // Delay read/write
    for sample_index in 0..data.num_samples() {
        for channel_index in 0..data.num_channels() {
            let input = *data.get(channel_index, sample_index);

            // Read delay output
            let delay_output = self.delay_buffers[channel_index][self.current_read_position];

            // Write input into delay with feedback
            let feedback = 0.3;
            self.delay_buffers[channel_index][self.current_write_position] =
                input + delay_output * feedback;

            // Output stage
            data.set(channel_index, sample_index, input + delay_output);
        }

        self.current_read_position += 1;
        self.current_write_position += 1;
    }
}

}

// Run it fn main() { let processor = SimpleDelayProcessor::new(); audioprocessorstandalone::audioprocessormain(processor); } ```