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
131
132
133
134

use crate::{prelude::*, synthesizer::RegionPair, utils};

use super::EnvelopeStage;

pub struct VolumeEnvelope {
    sample_rate: i32,

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

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

    release_start_time: f64,

    sustain_level: f32,
    release_level: f32,

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

impl VolumeEnvelope {
    pub fn new(settings: &SynthesizerSettings, region: &RegionPair, key: u8) -> Self {
        // If the release time is shorter than 10 ms, it will be clamped to 10 ms to avoid pop noise.
        let delay = region.get_delay_volume_envelope();
        let attack = region.get_attack_volume_envelope();
        let hold = region.get_hold_volume_envelope()
            * utils::key_number_to_multiplying_factor(
                region.get_key_number_to_volume_envelope_hold(),
                key,
            );
        let decay = region.get_decay_volume_envelope()
            * utils::key_number_to_multiplying_factor(
                region.get_key_number_to_volume_envelope_decay(),
                key,
            );
        let sustain = utils::decibels_to_linear(-region.get_sustain_volume_envelope());
        let release = region.get_release_volume_envelope().max(0.01_f32);

        let attack_slope = 1_f64 / attack as f64;
        let decay_slope = -9.226_f64 / decay as f64;
        let release_slope = -9.226_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 release_start_time = 0_f64;

        // saw this twice. wtf
        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,
            release_slope,
            sustain_level,
            processed_sample_count,
            stage,
            value,
            attack_slope,
            decay_slope,
            release_level,
            attack_start_time,
            hold_start_time,
            decay_start_time,
            release_start_time,
        };

        new.process(0);
        new
    }

    pub fn release(&mut self) {
        //TODO: make this algebraic
        self.stage = EnvelopeStage::Release;
        self.release_start_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;

        // interesting...
        //
        // Maybe we can refactor this to not loop
        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_f32),
            EnvelopeStage::Decay => {
                let val =
                    (utils::exp_cutoff(self.decay_slope * (current_time - self.decay_start_time))
                        as f32)
                        .max(self.sustain_level);

                (val > utils::NON_AUDIBLE).then_some(val)
            }
            EnvelopeStage::Release => {
                let val = (self.release_level as f64
                    * utils::exp_cutoff(
                        self.release_slope * (current_time - self.release_start_time),
                    )) as f32;
                //self.priority = self.value;
                (val > utils::NON_AUDIBLE).then_some(val)
            }
        }
    }
}