midix_synth 0.0.4

SoundFont compatible MIDI synthesizer for midix
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 crate::{prelude::*, synthesizer::RegionPair, utils};

use super::EnvelopeStage;

pub struct ModulationEnvelope {
    sample_rate: i32,

    attack_slope: f64,
    decay_slope: f64,
    release_slope: f64,

    attack_start_time: f64,
    hold_start_time: f64,
    decay_start_time: f64,

    decay_end_time: f64,
    release_end_time: f64,

    sustain_level: f32,
    release_level: f32,

    processed_sample_count: usize,
    stage: EnvelopeStage,
    value: f32,
}

impl ModulationEnvelope {
    pub fn new(settings: &SynthesizerSettings, region: &RegionPair, key: u8, velocity: u8) -> Self {
        // According to the implementation of TinySoundFont, the attack time should be adjusted by the velocity.
        let delay = region.get_delay_modulation_envelope();
        let attack = region.get_attack_modulation_envelope() * ((145 - velocity) as f32 / 144_f32);
        let hold = region.get_hold_modulation_envelope()
            * utils::key_number_to_multiplying_factor(
                region.get_key_number_to_modulation_envelope_hold(),
                key,
            );
        let decay = region.get_decay_modulation_envelope()
            * utils::key_number_to_multiplying_factor(
                region.get_key_number_to_modulation_envelope_decay(),
                key,
            );
        let sustain = 1_f32 - region.get_sustain_modulation_envelope() / 100_f32;
        let release = region.get_release_modulation_envelope();
        let attack_slope = 1_f64 / attack as f64;
        let decay_slope = 1_f64 / decay as f64;
        let release_slope = 1_f64 / release as f64;

        let attack_start_time = delay as f64;
        let hold_start_time = attack_start_time + attack as f64;
        let decay_start_time = hold_start_time + hold as f64;

        let decay_end_time = decay_start_time + decay as f64;
        let release_end_time = release as f64;

        let sustain_level = sustain.clamp(0., 1.);

        let release_level = 0_f32;

        let processed_sample_count = 0;
        let stage = EnvelopeStage::Delay;
        let value = 0_f32;
        let mut new = Self {
            sample_rate: settings.sample_rate,
            attack_slope,
            decay_slope,
            release_slope,
            attack_start_time,
            hold_start_time,
            decay_start_time,
            decay_end_time,
            release_end_time,
            sustain_level,
            release_level,
            processed_sample_count,
            stage,
            value,
        };

        new.process(0);
        new
    }

    pub fn release(&mut self) {
        self.stage = EnvelopeStage::Release;
        self.release_end_time += self.processed_sample_count as f64 / self.sample_rate as f64;
        self.release_level = self.value;
    }

    pub fn process(&mut self, sample_count: usize) -> Option<f32> {
        self.processed_sample_count += sample_count;

        let current_time = self.processed_sample_count as f64 / self.sample_rate as f64;

        while self.stage <= EnvelopeStage::Hold {
            let end_time = match self.stage {
                EnvelopeStage::Delay => self.attack_start_time,
                EnvelopeStage::Attack => self.hold_start_time,
                EnvelopeStage::Hold => self.decay_start_time,
                _ => panic!("Invalid envelope stage."),
            };

            if current_time < end_time {
                break;
            } else {
                self.stage = self.stage.next();
            }
        }
        match self.stage {
            EnvelopeStage::Delay => Some(0.),
            EnvelopeStage::Attack => {
                Some((self.attack_slope * (current_time - self.attack_start_time)) as f32)
            }
            EnvelopeStage::Hold => Some(1.),
            EnvelopeStage::Decay => {
                let val = ((self.decay_slope * (self.decay_end_time - current_time)) as f32)
                    .max(self.sustain_level);

                (val > utils::NON_AUDIBLE).then_some(val)
            }
            EnvelopeStage::Release => {
                let val = ((self.release_level as f64
                    * self.release_slope
                    * (self.release_end_time - current_time)) as f32)
                    .max(0.);

                (val > utils::NON_AUDIBLE).then_some(val)
            }
        }
    }
}