mkaudiolibrary 0.1.11

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
118
119
120
121
122
123
124
125
126
127

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.
    #[inline(always)]
    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.
    #[inline(always)]
    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.
    #[inline(always)]
    pub fn run(input : & Box<[f32]>, output : & mut Box<[f32]>, upper : Saturation<f32>, lower : Saturation<f32>)
    {
        for i in 0..input.len()
        {
            if input[i] > upper.lim + upper.gap { output[i] = upper.lim; }
            else if input[i] > upper.ths { output[i] =  upper.org + (upper.rad_pow - (upper.lim - input[i]).powi(2)).sqrt(); }
            else if input[i] < lower.lim - lower.gap { output[i] = upper.lim; }
            else if input[i] < lower.ths { output[i] = lower.org - (lower.rad_pow - (lower.lim - input[i]).powi(2)).sqrt(); }
            else { output[i] = input[i]; }
        }
    }
}
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.
    #[inline(always)]
    pub fn run(input : & Box<[f64]>, output : & mut Box<[f64]>, upper : Saturation<f64>, lower : Saturation<f64>)
    {
        for i in 0..input.len()
        {
            if input[i] > upper.lim + upper.gap { output[i] = upper.lim; }
            else if input[i] > upper.ths { output[i] =  upper.org + (upper.rad_pow - (upper.lim - input[i]).powi(2)).sqrt(); }
            else if input[i] < lower.lim - lower.gap { output[i] = upper.lim; }
            else if input[i] < lower.ths { output[i] = lower.org - (lower.rad_pow - (lower.lim - input[i]).powi(2)).sqrt(); }
            else { output[i] = input[i]; }
        }
    }
}

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