ruffbox_synth 0.14.0

A beatbox-oriented synthesizer library.
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

use crate::building_blocks::{
    Modulator, SampleBuffer, StereoPanner, SynthParameterLabel, SynthParameterValue,
};

use std::f32::consts::PI;

pub struct BalChan<const BUFSIZE: usize, const NCHAN: usize> {
    levels: [[[f32; BUFSIZE]; NCHAN]; 2],
    pos_mod: Option<Modulator<BUFSIZE>>,
    pos: f32,
}

impl<const BUFSIZE: usize, const NCHAN: usize> Default for BalChan<BUFSIZE, NCHAN> {
    fn default() -> Self {
        Self::new()
    }
}

impl<const BUFSIZE: usize, const NCHAN: usize> BalChan<BUFSIZE, NCHAN> {
    pub fn new() -> Self {
        let mut levels = [[[0.0; BUFSIZE]; NCHAN]; 2];

        levels[0][0] = [0.707; BUFSIZE];
        levels[1][0] = [0.707; BUFSIZE];

        // always start on first channel
        BalChan {
            levels,
            pos_mod: None,
            pos: 0.0,
        }
    }

    fn recalc_levels(&mut self, start_sample: usize, sample_buffers: &[SampleBuffer]) {
        if let Some(pm) = self.pos_mod.as_mut() {
            self.levels = [[[0.0; BUFSIZE]; NCHAN]; 2];
            let pos_buf = pm.process(self.pos, start_sample, sample_buffers);
            for (idx, p) in pos_buf.iter().enumerate() {
                let lower = p.floor();
                let angle_rad = (p - lower) * PI * 0.5;
                let upper = lower + 1.0;

                // only two channels are set at any time ...
                self.levels[0][lower as usize % NCHAN][idx] = angle_rad.cos();
                self.levels[1][upper as usize % NCHAN][idx] = angle_rad.sin();
            }
        }
    }
}

impl<const BUFSIZE: usize, const NCHAN: usize> StereoPanner<BUFSIZE, NCHAN>
    for BalChan<BUFSIZE, NCHAN>
{
    fn set_modulator(
        &mut self,
        par: SynthParameterLabel,
        init: f32,
        modulator: Modulator<BUFSIZE>,
    ) {
        if par == SynthParameterLabel::ChannelPosition {
            self.pos = init; // keep for later
            self.pos_mod = Some(modulator);
        }
    }

    /// Set the parameter for this panner.
    fn set_parameter(&mut self, par: SynthParameterLabel, value: &SynthParameterValue) {
        // if it was more parameters, match would be better,
        // but this way clippy doesn't complain
        if par == SynthParameterLabel::ChannelPosition
            && let SynthParameterValue::ScalarF32(p) = value
        {
            self.pos = *p; // keep for later

            self.levels = [[[0.0; BUFSIZE]; NCHAN]; 2];

            let lower = p.floor();
            let angle_rad = (p - lower) * PI * 0.5;
            let upper = lower + 1.0;

            // only two channels are set at any time ...
            self.levels[0][lower as usize % NCHAN] = [angle_rad.cos(); BUFSIZE];
            self.levels[1][upper as usize % NCHAN] = [angle_rad.sin(); BUFSIZE];
        }
    }
    /// pan stereo to stereo
    #[allow(clippy::needless_range_loop)]
    fn process_block(
        &mut self,
        block: [[f32; BUFSIZE]; 2],
        start_sample: usize,
        sample_buffers: &[SampleBuffer],
    ) -> [[f32; BUFSIZE]; NCHAN] {
        self.recalc_levels(start_sample, sample_buffers);

        // I think the range loop is way more intuitive and easy to read here ...
        let mut out_buf = [[0.0; BUFSIZE]; NCHAN];
        for c in 0..NCHAN {
            for s in 0..BUFSIZE {
                // this assumes paiwise panning
                out_buf[c][s] =
                    block[0][s] * self.levels[0][c][s] + block[1][s] * self.levels[1][c][s];
            }
        }
        out_buf
    }
}