sim-lib-audio-dsp 0.1.2

Reusable pure Rust DSP processors for the SIM audio graph.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use sim_lib_audio_graph_core::{PrepareConfig, ProcessBlock, Processor};

use crate::common::{input_sample, output_channels, prepare_channels};

/// A per-sample nonlinearity that can be wrapped by [`OversamplingWrapper`].
pub trait NonlinearSampleProcessor: Clone + Send {
    /// Clears any internal state.
    fn reset(&mut self);
    /// Maps one input sample to one output sample.
    fn process_sample(&mut self, input: f32) -> f32;
}

/// A tanh soft-clipping nonlinearity.
#[derive(Clone, Debug, PartialEq)]
pub struct TanhClipper {
    drive: f32,
}

impl TanhClipper {
    /// Creates a tanh clipper with the given drive (clamped to `>= 0`).
    pub fn new(drive: f32) -> Self {
        Self {
            drive: drive.max(0.0),
        }
    }
}

impl NonlinearSampleProcessor for TanhClipper {
    fn reset(&mut self) {}

    fn process_sample(&mut self, input: f32) -> f32 {
        (input * self.drive).tanh()
    }
}

/// A [`Processor`] that runs a [`NonlinearSampleProcessor`] at an integer
/// oversampling factor, interpolating each input across the oversampled steps.
#[derive(Clone, Debug, PartialEq)]
pub struct OversamplingWrapper<P: NonlinearSampleProcessor> {
    prototype: P,
    processors: Vec<P>,
    previous_inputs: Vec<f32>,
    factor: u8,
}

impl<P: NonlinearSampleProcessor> OversamplingWrapper<P> {
    /// Wraps a nonlinearity at the given oversampling factor (clamped to
    /// `1..=16`).
    pub fn new(processor: P, factor: u8) -> Self {
        Self {
            prototype: processor,
            processors: Vec::new(),
            previous_inputs: Vec::new(),
            factor: factor.clamp(1, 16),
        }
    }

    fn process_channel_sample(&mut self, channel: usize, input: f32) -> f32 {
        let previous = self.previous_inputs[channel];
        let mut output = 0.0;
        for step in 1..=self.factor {
            let t = step as f32 / self.factor as f32;
            let upsampled = previous + (input - previous) * t;
            output = self.processors[channel].process_sample(upsampled);
        }
        self.previous_inputs[channel] = input;
        output
    }
}

impl OversamplingWrapper<TanhClipper> {
    /// Creates an oversampled tanh soft clipper with the given drive and factor.
    pub fn soft_clipper(drive: f32, factor: u8) -> Self {
        Self::new(TanhClipper::new(drive), factor)
    }
}

impl<P: NonlinearSampleProcessor> Processor for OversamplingWrapper<P> {
    fn prepare(&mut self, cfg: PrepareConfig) {
        prepare_channels(
            &mut self.processors,
            cfg.out_channels as usize,
            self.prototype.clone(),
        );
        prepare_channels(&mut self.previous_inputs, cfg.out_channels as usize, 0.0);
    }

    fn reset(&mut self) {
        self.previous_inputs.fill(0.0);
        for processor in &mut self.processors {
            processor.reset();
        }
    }

    fn process(&mut self, block: &mut ProcessBlock<'_>) {
        let channels = output_channels(block);
        if self.processors.len() < channels {
            self.processors.resize(channels, self.prototype.clone());
            self.previous_inputs.resize(channels, 0.0);
        }
        let frames = block.frames as usize;
        for channel in 0..channels {
            for frame in 0..frames {
                let input = input_sample(block, channel, frame);
                block.out_audio[channel][frame] = self.process_channel_sample(channel, input);
            }
        }
    }
}

/// An oversampled tanh soft clipper, the default [`OversamplingWrapper`].
pub type OversampledSoftClipper = OversamplingWrapper<TanhClipper>;