culsynth 0.2.0

Culsynth DSP 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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use super::*;

/// A parameter pack for [MixOsc].
#[derive(Clone, Default)]
pub struct MixOscParams<T: DspFormatBase> {
    /// The tuning offset, in semitones offset from 12TET/A440
    pub tune: T::NoteOffset,
    /// The oscillator shape parameter, ranging from 0-1 and representing the
    /// amount of phase distortion/pulse width ratio for this output
    pub shape: T::Scalar,
    /// Sine wave gain
    pub sin: T::Scalar,
    /// Square wave gain
    pub sq: T::Scalar,
    /// Triangle wave gain
    pub tri: T::Scalar,
    /// Sawtooth wave gain
    pub saw: T::Scalar,
}

impl<T: DspFloat> From<&MixOscParams<i16>> for MixOscParams<T> {
    fn from(value: &MixOscParams<i16>) -> Self {
        MixOscParams::<T> {
            tune: value.tune.to_num(),
            shape: value.shape.to_num(),
            sin: value.sin.to_num(),
            sq: value.sq.to_num(),
            tri: value.tri.to_num(),
            saw: value.saw.to_num(),
        }
    }
}

impl<T: DspFormatBase> MixOscParams<T> {
    /// Extract the basic oscillator parameters from this parameter pack.
    pub fn to_osc_params(&self) -> OscParams<T> {
        OscParams {
            tune: self.tune,
            shape: self.shape,
        }
    }
}

/// This wraps [Osc], combining the oscillator with a mixer for each of the
/// wave shapes and taking the gain of each wave as a parameter.  This provides
/// a pre-mixed output as a single signal.
///
/// This implements [Device], taking a Note as input and [MixOscParams] as
/// parameters, and outputs a Sample representing the sum of the different
/// waveforms scaled by their respective gains.
#[derive(Clone, Default)]
pub struct MixOsc<T: DspFormat> {
    mixer: Mixer<T, 4>,
    osc: Osc<T>,
}

impl<T: DspFormat> Device<T> for MixOsc<T> {
    type Input = T::Note;
    type Params = MixOscParams<T>;
    type Output = T::Sample;
    fn next(&mut self, context: &T::Context, note: T::Note, params: MixOscParams<T>) -> T::Sample {
        let osc_out = self.osc.next(context, note, params.to_osc_params());
        self.mixer.next(
            context,
            [osc_out.sin, osc_out.sq, osc_out.tri, osc_out.saw],
            [params.sin, params.sq, params.tri, params.saw],
        )
    }
}

/// This struct contains parameters for a synced oscillator pair
#[derive(Clone, Default)]
pub struct SyncedMixOscsParams<T: DspFormatBase> {
    /// Parameters for the primary oscillator
    pub primary: MixOscParams<T>,
    /// Parameters for the secondary (synced) oscillator
    pub secondary: MixOscParams<T>,
    /// True if oscillator sync has been enabled - when false, both oscillators
    /// will run independently
    pub sync: bool,
}

impl<T: DspFloat> From<&SyncedMixOscsParams<i16>> for SyncedMixOscsParams<T> {
    fn from(value: &SyncedMixOscsParams<i16>) -> Self {
        Self {
            primary: (&value.primary).into(),
            secondary: (&value.secondary).into(),
            sync: value.sync,
        }
    }
}

/// The output of a [SyncedMixOscs] device.
#[derive(Clone, Default)]
pub struct SyncedMixOscsOutput<T: DspFormatBase> {
    /// The output of the primary oscillator
    pub primary: T::Sample,
    /// The output of the secondary oscillator
    pub secondary: T::Sample,
}

/// A synced pair of [MixOsc]s.  The secondary oscillator will be synced
/// to the primary oscillator.
///
/// This implements [Device], taking a Note as input and a [SyncedMixOscsParams]
/// as parameters.  It outputs a [SyncedMixOscsOutput], which is just the pair
/// of Sample outputs from the underlying [Osc].
///
/// See also: [SyncedOscs], [Osc]
#[derive(Clone, Default)]
pub struct SyncedMixOscs<T: DspFormat> {
    oscs: SyncedOscs<T>,
    mixer_pri: Mixer<T, 4>,
    mixer_sec: Mixer<T, 4>,
}

impl<T: DspFormat> Device<T> for SyncedMixOscs<T> {
    type Input = T::Note;
    type Params = SyncedMixOscsParams<T>;
    type Output = SyncedMixOscsOutput<T>;
    fn next(
        &mut self,
        context: &T::Context,
        note: T::Note,
        params: SyncedMixOscsParams<T>,
    ) -> Self::Output {
        let inputs = SyncedOscsParams {
            primary: params.primary.to_osc_params(),
            secondary: params.secondary.to_osc_params(),
            sync: params.sync,
        };
        let SyncedOscsOutput {
            primary: p,
            secondary: s,
        } = self.oscs.next(context, note, inputs);
        let pri_out = self.mixer_pri.next(
            context,
            [p.sin, p.sq, p.tri, p.saw],
            [
                params.primary.sin,
                params.primary.sq,
                params.primary.tri,
                params.primary.saw,
            ],
        );
        let sec_out = self.mixer_sec.next(
            context,
            [s.sin, s.sq, s.tri, s.saw],
            [
                params.secondary.sin,
                params.secondary.sq,
                params.secondary.tri,
                params.secondary.saw,
            ],
        );
        SyncedMixOscsOutput {
            primary: pri_out,
            secondary: sec_out,
        }
    }
}