rabu 0.3.1

Rust Audio Basic Utilies
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

//! This module contains a biquad filter that can be instantiated
//! with provided coefficients. On top of that it contains some functions to create
//! the coefficients for the basic filter types.
//! Example of a low pass filter:
//! ```rust
//! use rabu::biquad::{BiquadFilter, low_pass_coefficients};
//! use rabu::units::{Frequency, SampleRate};
//!
//! let sample_rate = SampleRate::from(44100);
//! let cutoff = Frequency::from(1000.0);
//! let coefficients = low_pass_coefficients(sample_rate, cutoff);
//!
//! let mut filter = BiquadFilter::new(coefficients);
//!
//! let input_sample = 0.5;
//! let output_sample = filter.process(input_sample);
//! ```

use crate::units::{Frequency, SampleRate};

/// The coefficients for a `BiquadFilter`.
pub struct BiquadCoefficients {
    pub a1: f64,
    pub a2: f64,
    pub b0: f64,
    pub b1: f64,
    pub b2: f64,
}

/// A biquad filter used to filter audio signals.
pub struct BiquadFilter {
    coefficients: BiquadCoefficients,
    x1: f64,
    x2: f64,
    y1: f64,
    y2: f64,
}

impl BiquadFilter {
    /// Creates a new biquad filter using the provided coefficients.
    pub fn new(coefficients: BiquadCoefficients) -> Self {
        Self {
            coefficients,
            x1: 0.0,
            x2: 0.0,
            y1: 0.0,
            y2: 0.0,
        }
    }

    /// Sets the coefficients to the provided ones.
    pub fn set_coefficients(&mut self, coefficients: BiquadCoefficients) {
        self.coefficients = coefficients;
    }

    /// Processes one sample of input audio and produces the filter output sample.
    pub fn process(&mut self, input: f64) -> f64 {
        let output = self.coefficients.b0 * input
            + self.coefficients.b1 * self.x1
            + self.coefficients.b2 * self.x2
            - self.coefficients.a1 * self.y1
            - self.coefficients.a2 * self.y2;
        self.x2 = self.x1;
        self.x1 = input;
        self.y2 = self.y1;
        self.y1 = output;
        output
    }
}

/// Creates the biquad coefficients for a low pass filter,
/// given a sample rate and a cutoff frequency.
pub fn low_pass_coefficients(
    sample_rate: SampleRate,
    cutoff_frequency: Frequency,
) -> BiquadCoefficients {
    let w0 = 2.0 * std::f64::consts::PI * cutoff_frequency.as_f64() / sample_rate.as_f64();
    let cos_w0 = w0.cos();
    let sin_w0 = w0.sin();
    let alpha = sin_w0 / (2.0 * 0.5);

    let b0 = (1.0 - cos_w0) / 2.0;
    let b1 = 1.0 - cos_w0;
    let b2 = (1.0 - cos_w0) / 2.0;
    let a0 = 1.0 + alpha;
    let a1 = -2.0 * cos_w0;
    let a2 = 1.0 - alpha;

    BiquadCoefficients {
        b0: b0 / a0,
        b1: b1 / a0,
        b2: b2 / a0,
        a1: a1 / a0,
        a2: a2 / a0,
    }
}

/// Creates the biquad coefficients for a band pass filter,
/// given a sample rate and a cutoff frequency.
pub fn band_pass_coefficients(
    sample_rate: SampleRate,
    center_frequency: Frequency,
    bandwidth: f64,
) -> BiquadCoefficients {
    let w0 = 2.0 * std::f64::consts::PI * center_frequency.as_f64() / sample_rate.as_f64();
    let cos_w0 = w0.cos();
    let sin_w0 = w0.sin();
    let alpha = sin_w0 * std::f64::consts::SQRT_2 / 2.0 * bandwidth / center_frequency.as_f64();

    let b0 = sin_w0 / 2.0;
    let b1 = 0.0;
    let b2 = -sin_w0 / 2.0;
    let a0 = 1.0 + alpha;
    let a1 = -2.0 * cos_w0;
    let a2 = 1.0 - alpha;

    BiquadCoefficients {
        b0: b0 / a0,
        b1: b1 / a0,
        b2: b2 / a0,
        a1: a1 / a0,
        a2: a2 / a0,
    }
}

/// Creates the biquad coefficients for a high pass filter,
/// given a sample rate and a cutoff frequency.
pub fn high_pass_coefficients(
    sample_rate: SampleRate,
    cutoff_frequency: Frequency,
) -> BiquadCoefficients {
    let w0 = 2.0 * std::f64::consts::PI * cutoff_frequency.as_f64() / sample_rate.as_f64();
    let cos_w0 = w0.cos();
    let sin_w0 = w0.sin();
    let alpha = sin_w0 / (2.0 * 0.5);

    let b0 = (1.0 + cos_w0) / 2.0;
    let b1 = -(1.0 + cos_w0);
    let b2 = (1.0 + cos_w0) / 2.0;
    let a0 = 1.0 + alpha;
    let a1 = -2.0 * cos_w0;
    let a2 = 1.0 - alpha;

    BiquadCoefficients {
        b0: b0 / a0,
        b1: b1 / a0,
        b2: b2 / a0,
        a1: a1 / a0,
        a2: a2 / a0,
    }
}