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
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! You create a new synthesizer with [`Synth::new()`].
//! Use the settings structure to specify the synthesizer characteristics.
//!
//! You have to load a SoundFont in order to hear any sound.
//! For that you use the [`Synth::add_font()`] function.
//!
//! To send events use: [`Synth::send_event()`] function.
//!
//! To write the results to a buffer use [`Synth::write()`] function.

mod api;
mod arena;
mod core;
mod error;
mod midi_event;

mod unsafe_stuff;

pub use api::Tuning;
pub use core::{GeneratorType, InterpolationMethod, Preset, SoundFont};
pub use error::{OxiError, RangeError, SettingsError};
pub use midi_event::MidiEvent;

#[doc(inline)]
pub use oxisynth_chorus::ChorusParams;
#[doc(inline)]
pub use oxisynth_reverb::ReverbParams;

#[doc(hidden)]
pub use arena::Index;
pub type SoundFontId = Index<SoundFont>;

pub struct SynthDescriptor {
    pub reverb_active: bool,
    pub chorus_active: bool,
    pub drums_channel_active: bool,
    // Interpolation method/quality
    pub interpolation: InterpolationMethod,

    /// Def: 256
    /// Min: 1
    /// Max: 65535
    pub polyphony: u16,
    /// Def: 16
    /// Min: 16
    /// Max: 256
    pub midi_channels: u8,
    /// Def: 0.2
    /// Min: 0.0
    /// Max: 10.0
    pub gain: f32,
    /// Def: 1
    /// Min: 1
    /// Max: 128
    pub audio_channels: u8,
    /// Def: 1
    /// Min: 1
    /// Max: 128
    pub audio_groups: u8,
    /// Def: 44100.0
    /// Min: 8000.0
    /// Max: 96000.0
    pub sample_rate: f32,
    /// Def: 10
    /// Min: 0
    /// Max: 65535
    pub min_note_length: u16,
}

impl Default for SynthDescriptor {
    fn default() -> Self {
        Self {
            reverb_active: true,
            chorus_active: true,
            drums_channel_active: true,
            interpolation: InterpolationMethod::default(),

            polyphony: 256,
            midi_channels: 16,
            gain: 0.2,
            audio_channels: 1,
            audio_groups: 1,
            sample_rate: 44100.0,
            min_note_length: 10,
        }
    }
}

/// The synth object
///
/// You create a new synthesizer with [`Synth::new()`].
/// Use the settings structure to specify the synthesizer characteristics.
///
/// You have to load a SoundFont in order to hear any sound.
/// For that you use the [`Synth::add_font()`] function.
///
/// To send events use: [`Synth::send_event()`] function.
///
/// To write the results to a buffer use [`Synth::write()`] function.
#[derive(Default)]
pub struct Synth {
    core: crate::core::Core,
}

impl Synth {
    /// Creates a new synthesizer object.
    ///
    /// As soon as the synthesizer is created, it will start playing.
    pub fn new(desc: SynthDescriptor) -> Result<Self, SettingsError> {
        Ok(Synth {
            core: crate::core::Core::new(desc)?,
        })
    }
}

#[cfg(test)]
mod test {
    use crate::{MidiEvent, SoundFont, Synth, SynthDescriptor};
    use std::{fs::File, io::Write};

    #[test]
    fn synth_sf2() {
        let mut pcm = File::create("Boomwhacker.sf2.pcm").unwrap();

        let mut synth = Synth::new(SynthDescriptor::default()).unwrap();

        let mut file = std::fs::File::open("../testdata/Boomwhacker.sf2").unwrap();
        let font = SoundFont::load(&mut file).unwrap();

        synth.add_font(font, true);

        let mut samples = [0f32; 44100 * 2];

        synth
            .send_event(MidiEvent::NoteOn {
                channel: 0,
                key: 60,
                vel: 127,
            })
            .unwrap();

        synth.write(samples.as_mut());
        pcm.write_all(crate::unsafe_stuff::slice_f32_to_u8(&samples))
            .unwrap();

        synth
            .send_event(MidiEvent::NoteOff {
                channel: 0,
                key: 60,
            })
            .unwrap();

        synth.write(samples.as_mut());
        pcm.write_all(crate::unsafe_stuff::slice_f32_to_u8(&samples))
            .unwrap();

        drop(synth);
    }
}