ruffbox_synth 0.14.0

A beatbox-oriented synthesizer library.
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

use crate::building_blocks::interpolation::interpolate;

/// stretch (interpolate) buffer to target size
pub fn stretch_to_size(buf: &[f32], target_size: usize) -> Vec<f32> {
    let ratio = (buf.len() - 3) as f32 / target_size as f32;

    //println!("ratio {}", ratio);

    let mut out_buf = vec![0.0; target_size];
    let mut frac_index: f32 = 1.0;
    let frac_index_increment = ratio;

    for current_sample in out_buf.iter_mut() {
        // get sample:
        let idx = frac_index.floor();
        let frac = frac_index - idx;
        let idx_u = idx as usize;

        // 4-point, 3rd-order Hermite
        *current_sample = interpolate(
            frac,
            buf[idx_u - 1],
            buf[idx_u],
            buf[idx_u + 1],
            buf[idx_u + 2],
            1.0,
        );

        if ((frac_index + frac_index_increment) as usize) < (buf.len() - 3) {
            frac_index += frac_index_increment;
        }
    }

    out_buf
}

/// find next upward zerocrossing, starting at idx
pub fn find_closest_upward_zerocrossing(buffer: &[f32], idx: usize) -> usize {
    let mut idx_u = idx;
    for i in idx - 1..buffer.len() - 1 {
        if buffer[i] <= 0.0 && buffer[i + 1] > 0.0 {
            idx_u = i;
            break;
        }
    }
    let mut idx_d = idx;
    for i in (1..idx + 1).rev() {
        if buffer[i - 1] <= 0.0 && buffer[i] > 0.0 {
            idx_d = i;
            break;
        }
    }
    if idx - idx_d < idx_u - idx {
        idx_d
    } else {
        idx_u
    }
}

/// find next downward zerocrossing, starting at idx
pub fn find_closest_downward_zerocrossing(buffer: &[f32], idx: usize) -> usize {
    let mut idx_u = idx;
    for i in idx - 1..buffer.len() - 1 {
        if buffer[i] >= 0.0 && buffer[i + 1] < 0.0 {
            idx_u = i;
            break;
        }
    }
    let mut idx_d = idx;
    for i in (1..idx + 1).rev() {
        if buffer[i - 1] >= 0.0 && buffer[i] < 0.0 {
            idx_d = i;
            break;
        }
    }
    if idx - idx_d < idx_u - idx {
        idx_d
    } else {
        idx_u
    }
}

/// find the next zero crossing on beginning and end of the buffer
pub fn find_zerocrossings(buffer: &[f32], reverse: bool) -> (usize, usize, usize) {
    // find zerocrossing from new to pos
    let mut start_idx = 0;
    let mut end_idx = buffer.len();

    if reverse {
        for i in 0..buffer.len() - 1 {
            if buffer[i] > 0.0 && buffer[i + 1] <= 0.0 || buffer[i] == 0.0 && buffer[i + 1] < 0.0 {
                start_idx = i;
                break;
            }
        }

        for i in (1..buffer.len() - 1).rev() {
            if buffer[i] < 0.0 && buffer[i - 1] >= 0.0 || buffer[i] == 0.0 && buffer[i - 1] > 0.0 {
                end_idx = i;
                break;
            }
        }
    } else {
        for i in 0..buffer.len() - 1 {
            if buffer[i] < 0.0 && buffer[i + 1] >= 0.0 || buffer[i] == 0.0 && buffer[i + 1] > 0.0 {
                start_idx = i;
                break;
            }
        }

        for i in (1..buffer.len() - 1).rev() {
            if buffer[i] > 0.0 && buffer[i - 1] <= 0.0 || buffer[i] == 0.0 && buffer[i - 1] < 0.0 {
                end_idx = i;
                break;
            }
        }
    }

    (start_idx, end_idx + 1, end_idx + 1 - start_idx)
}