ruffbox_synth 0.14.0

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

/**
 * A non-band-limited impulse generator.
 *
 * Probably the most naive implementation of such an oscillator,
 * doesn't tune well, etc ...
 */
#[derive(Clone)]
pub struct LFImpulse<const BUFSIZE: usize> {
    //user values
    freq: f32,
    amp: f32,

    // internal values
    samplerate: f32,
    period_samples: usize,
    period_count: usize,

    // modulator slots
    freq_mod: Option<Modulator<BUFSIZE>>, // currently allows modulating frequency ..
    amp_mod: Option<Modulator<BUFSIZE>>,  // and level
    pw_mod: Option<Modulator<BUFSIZE>>,   // and pulsewidth
}

impl<const BUFSIZE: usize> LFImpulse<BUFSIZE> {
    pub fn new(freq: f32, amp: f32, samplerate: f32) -> Self {
        LFImpulse {
            freq,
            amp,
            samplerate,
            period_samples: (samplerate / freq).round() as usize,
            period_count: 0,
            freq_mod: None,
            amp_mod: None,
            pw_mod: None,
        }
    }
}

impl<const BUFSIZE: usize> MonoSource<BUFSIZE> for LFImpulse<BUFSIZE> {
    fn reset(&mut self) {}

    fn set_modulator(
        &mut self,
        par: SynthParameterLabel,
        init: f32,
        modulator: Modulator<BUFSIZE>,
    ) {
        match par {
            SynthParameterLabel::PitchFrequency => {
                self.freq = init;
                self.freq_mod = Some(modulator);
            }
            SynthParameterLabel::OscillatorAmplitude => {
                self.amp = init;
                self.amp_mod = Some(modulator);
            }
            _ => {}
        }
    }

    fn set_parameter(&mut self, par: SynthParameterLabel, value: &SynthParameterValue) {
        match par {
            SynthParameterLabel::PitchFrequency => {
                if let SynthParameterValue::ScalarF32(f) = value {
                    self.freq = *f;
                    self.period_samples = (self.samplerate / *f).round() as usize;
                }
            }
            SynthParameterLabel::OscillatorAmplitude => {
                if let SynthParameterValue::ScalarF32(l) = value {
                    self.amp = *l;
                }
            }
            _ => (),
        };
    }

    fn finish(&mut self) {}

    fn is_finished(&self) -> bool {
        false
    }

    fn get_next_block(
        &mut self,
        start_sample: usize,
        in_buffers: &[SampleBuffer],
    ) -> [f32; BUFSIZE] {
        let mut out_buf: [f32; BUFSIZE] = [0.0; BUFSIZE];

        if self.freq_mod.is_some() || self.amp_mod.is_some() || self.pw_mod.is_some() {
            let amp_buf = if let Some(m) = self.amp_mod.as_mut() {
                m.process(self.amp, start_sample, in_buffers)
            } else {
                [self.amp; BUFSIZE]
            };

            let freq_buf = if let Some(m) = self.freq_mod.as_mut() {
                m.process(self.freq, start_sample, in_buffers)
            } else {
                [self.freq; BUFSIZE]
            };

            for (idx, current_sample) in out_buf
                .iter_mut()
                .enumerate()
                .take(BUFSIZE)
                .skip(start_sample)
            {
                self.period_samples = (self.samplerate / freq_buf[idx]).round() as usize;

                if self.period_count > self.period_samples {
                    self.period_count = 0;
                }

                if self.period_count == 0 {
                    *current_sample = amp_buf[idx];
                }

                self.period_count += 1;
            }
        } else {
            for current_sample in out_buf.iter_mut().take(BUFSIZE).skip(start_sample) {
                if self.period_count > self.period_samples {
                    self.period_count = 0;
                }

                if self.period_count == 0 {
                    *current_sample = self.amp;
                }

                self.period_count += 1;
            }
        }

        out_buf
    }
}