mkaudiolibrary 0.1.13

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
128
129
130

use std::alloc::LayoutError;

use crate::buffer::{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>
{
    #[inline]
    pub fn new(data : & [f32]) -> Result<Self, LayoutError>
    {
        let mut window = Self
        {
            buffer : PushBuffer::<f32>::new(data.len())?,
            window : Box::<[f32]>::from(data),
        };
        window.buffer.index = window.buffer.len();
        return Ok(window);
    }
    ///Convolve input data into window, then returns into output.
    #[inline]
    pub fn run(& mut self, input : & Buffer<f32>, output : & mut Buffer<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>
{
    #[inline]
    pub fn new(data : & [f64]) -> Result<Self, LayoutError>
    {
        let mut window = Self
        {
            buffer : PushBuffer::<f64>::new(data.len())?,
            window : Box::<[f64]>::from(data),
        };
        window.buffer.index = window.buffer.len();
        return Ok(window);
    }
    ///Convolve input data into window, then returns into output.
    #[inline]
    pub fn run(& mut self, input : & Buffer<f64>, output : & mut Buffer<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.
    #[inline]
    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]
    pub fn run(input : & Buffer<f32>, output : & mut Buffer<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.
    #[inline]
    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]
    pub fn run(input : & Buffer<f64>, output : & mut Buffer<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]; }
        }
    }
}