aych-delay 0.1.1

A delay effect modelled after the H-Delay by Waves
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

// "Topology preserving transform" one-pole filter.
//
// Derived from the soul-lang project (ISC license),
// which is derived from work by Zavalishin and Pirkle.
// https://github.com/soul-lang/SOUL

use crate::filters::{Filter, Mode};
use std::f64::consts::PI;

const MIN_FREQ: f64 = 5.0;
const MAX_FREQ: f64 = 22000.0;
const NORMALIZED_FREQ_LIMIT: f64 = 0.49;

fn get_coefficient(sample_rate: f64, freq_hz: f64) -> f64 {
    let wd = 2.0 * PI * freq_hz;
    let t = 1.0 / sample_rate;
    let wa = (2.0 / t) * (wd * t / 2.0).tan();
    let g = wa * t / 2.0;

    g / (1.0 + g)
}

pub struct TPTOnePole {
    mode: Mode,
    b: f64,
    z1: f32,
}

impl TPTOnePole {
    pub fn new(mode: Mode, sample_rate: f64, freq_hz: f64) -> Self {
        // Clamp the frequency to the Nyquist frequency
        let freq_hz = freq_hz.max(MIN_FREQ).min(MAX_FREQ * NORMALIZED_FREQ_LIMIT);

        Self {
            mode,
            b: get_coefficient(sample_rate, freq_hz),
            z1: 0.0,
        }
    }

    fn process_lpf(&mut self, input: f32) -> f32 {
        let vn = (input - self.z1) * self.b as f32;
        let lpf = vn + self.z1;
        self.z1 = vn + lpf;

        lpf
    }

    fn process_hpf(&mut self, input: f32) -> f32 {
        input - self.process_lpf(input)
    }

    fn process_apf(&mut self, input: f32) -> f32 {
        let lpf = self.process_lpf(input);
        let hpf = input - lpf;

        lpf - hpf
    }
}

impl Filter for TPTOnePole {
    fn process(&mut self, input: f32) -> f32 {
        match self.mode {
            Mode::LOWPASS => self.process_lpf(input),
            Mode::HIGHPASS => self.process_hpf(input),
            Mode::ALLPASS => self.process_apf(input),
        }
    }
}

pub struct TPTOnePoleStereo {
    left: TPTOnePole,
    right: TPTOnePole,
}

impl TPTOnePoleStereo {
    pub fn new(mode: Mode, sample_rate: f64, freq_hz: f64) -> Self {
        Self {
            left: TPTOnePole::new(mode.clone(), sample_rate, freq_hz),
            right: TPTOnePole::new(mode.clone(), sample_rate, freq_hz),
        }
    }

    pub fn process(&mut self, input: (f32, f32)) -> (f32, f32) {
        (self.left.process(input.0), self.right.process(input.1))
    }
}