mkaudiolibrary 0.1.8

Modular audio processing library including MKAU plugin format based on Rust.
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

use crate::buffer::PushBuffer;

///Buffer and window for convolution. Buffer stores data for continuation. Generic T must be either f32 or f64.
pub struct Convolution<T>
{
    buffer : PushBuffer<T>,
    window : Box<[T]>
}
impl Convolution<f32>
{
    pub fn new(data : & [f32]) -> Self
    {
        let mut window = Self
        {
            buffer : PushBuffer::<f32>::new(data.len()),
            window : Box::<[f32]>::from(data),
        };
        window.buffer.index = window.buffer.len();
        return window;
    }
    ///Convolve input data into window, then returns into output.
    pub fn run(& mut self, input : & Box<[f32]>, output : & mut Box<[f32]>)
    {
        let mut data = 0.0;
        for x in 0..input.len()
        {
            self.buffer.push(input[x]);
            (0..self.window.len()).for_each(|x| data += self.buffer[x] * self.window[x]);
            output[x] = data;
        }
    }
}
impl Convolution<f64>
{
    pub fn new(data : & [f64]) -> Self
    {
        let mut window = Self
        {
            buffer : PushBuffer::<f64>::new(data.len()),
            window : Box::<[f64]>::from(data),
        };
        window.buffer.index = window.buffer.len();
        return window;
    }
    ///Convolve input data into window, then returns into output.
    pub fn run(& mut self, input : & Box<[f64]>, output : & mut Box<[f64]>)
    {
        let mut data = 0.0;
        for x in 0..input.len()
        {
            self.buffer.push(input[x]);
            (0..self.window.len()).for_each(|x| data += self.buffer[x] * self.window[x]);
            output[x] = data;
        }
    }
}

///Set saturation character for one side. Generic T must be either f32 or f64.
pub struct Saturation<T>
{
    ths : T,
    lim : T,
    gap : T,
    rad_pow : T,
    org : T
}
impl Saturation<f32>
{
    ///New saturation data.
    pub fn new(ths : f32, lim : f32) -> Self
    {
        let gap = lim - ths;
        let side = ((gap * 2.0).powi(2) + gap.powi(2)).sqrt();
        let ang = 180.0 - 2.0 * (gap * 2.0 / side).asin();
        let rad = side / (2.0 * (ang/2.0).sin());
        let rad_pow = rad.powi(2);
        let org = lim - rad;

        return Self { ths, lim, gap, rad_pow, org }
    }
    ///Process each data for non-linear behavior.
    pub fn run(data : f32, upper : Saturation<f32>, lower : Saturation<f32>) -> f32
    {
        return if data > upper.lim + upper.gap { upper.lim }
        else if data > upper.ths { upper.org + (upper.rad_pow - (upper.lim - data).powi(2)).sqrt() }
        else if data < lower.lim - lower.gap { upper.lim }
        else if data < lower.ths { lower.org - (lower.rad_pow - (lower.lim - data).powi(2)).sqrt() }
        else { 0.0 }
    }
}
impl Saturation<f64>
{
    ///New saturation data.
    pub fn new(ths : f64, lim : f64) -> Self
    {
        let gap = lim - ths;
        let side = ((gap * 2.0).powi(2) + gap.powi(2)).sqrt();
        let ang = 180.0 - 2.0 * (gap * 2.0 / side).asin();
        let rad = side / (2.0 * (ang/2.0).sin());
        let rad_pow = rad.powi(2);
        let org = lim - rad;

        return Self { ths, lim, gap, rad_pow, org }
    }
    ///Process each data for non-linear behavior.
    pub fn saturation(data : f64, upper : Saturation<f64>, lower : Saturation<f64>) -> f64
    {
        return if data > upper.lim + upper.gap { upper.lim }
        else if data > upper.ths { upper.org + (upper.rad_pow - (upper.lim - data).powi(2)).sqrt() }
        else if data < lower.lim - lower.gap { upper.lim }
        else if data < lower.ths { lower.org - (lower.rad_pow - (lower.lim - data).powi(2)).sqrt() }
        else { 0.0 }
    }
}

///Read and write data from boxed slice I/O. !next to pause. !state to stop.
pub type Process = fn(input : & Box<[f64]>, output : & mut Box<[f64]>, next : & bool, state : & bool);