oxisynth 0.1.0

Rust soundfont synthesizer
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

use std::sync::LazyLock;

use crate::core::Core;

static RAND_TABLE: LazyLock<[[f32; 48000]; 2]> = LazyLock::new(|| {
    let mut rand: [[f32; 48000]; 2] = [[0.0; 48000]; 2];

    for c in rand.iter_mut() {
        let mut dp = 0.0;

        for i in c.iter_mut().take(48000 - 1) {
            let r: i32 = rand::random();
            let d = r as f32 / 2147483647.0 - 0.5;
            *i = d - dp;
            dp = d;
        }

        c[48000 - 1] = 0.0 - dp;
    }

    rand
});

/// Stored in [`Synth::i16_output`]
#[derive(Default)]
pub(crate) struct I16OutputState {
    dither_index: usize,
}

#[inline]
pub fn write_i16(
    synth: &mut Core,
    len: usize,
    loff: usize,
    lincr: usize,
    roff: usize,
    rincr: usize,
    mut cb: impl FnMut((usize, i16), (usize, i16)),
) {
    let mut di = synth.output.i16_output.dither_index;

    let mut cur = synth.output.cur;
    let mut i = 0;
    let mut j = loff;
    let mut k = roff;

    while i < len {
        // fill up the buffers as needed
        if cur == 64 {
            synth.one_block(false);
            cur = 0;
        }

        // Converts stereo floating point sample data to signed 16 bit data with
        // dithering.

        let mut left_sample =
            f32::round(synth.output.left_buf[0][cur] * 32766.0 + RAND_TABLE[0][di]);
        let mut right_sample =
            f32::round(synth.output.right_buf[0][cur] * 32766.0 + RAND_TABLE[1][di]);

        di += 1;
        if di >= 48000 {
            di = 0;
        }

        // digital clipping
        left_sample = left_sample.clamp(-32768.0, 32767.0);
        right_sample = right_sample.clamp(-32768.0, 32767.0);

        cb(
            (j, left_sample as i16),
            (k, right_sample as i16),
            //
        );

        i += 1;
        cur += 1;
        j += lincr;
        k += rincr
    }

    synth.output.cur = cur;

    // keep dither buffer continuous
    synth.output.i16_output.dither_index = di;
}