rsynth 0.1.2

A library for developing audio plugins and applications, with a focus on software synthesis.
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

use super::MICROSECONDS_PER_SECOND;
use crate::backend::combined::MidiWriter;
use crate::event::{DeltaEvent, RawMidiEvent};
use rimd::{Event, MetaCommand, MetaEvent, MidiMessage, SMFBuilder, TrackEvent, SMF};

const SECONDS_PER_MINUTE: u64 = 60;
const MICROSECONDS_PER_MINUTE: u64 = SECONDS_PER_MINUTE * MICROSECONDS_PER_SECOND;

const DEFAULT_BEATS_PER_MINUTE: u64 = 120;

pub struct RimdMidiReader<'a> {
    track_iterator: std::slice::Iter<'a, TrackEvent>,
    current_tempo_in_micro_seconds_per_beat: f64,
    ticks_per_beat: f64,
}

impl<'a> RimdMidiReader<'a> {
    pub fn ticks_per_microsecond(&self) -> f64 {
        self.ticks_per_beat / self.current_tempo_in_micro_seconds_per_beat
    }

    pub fn new(input_file: &'a SMF, track_index: usize) -> Self {
        if input_file.tracks.len() < track_index {
            unimplemented!("Implement better error handling when the track index cannot be found");
        }
        if input_file.division < 0 {
            unimplemented!("Support 'negative' time division");
        }
        let ticks_per_beat = input_file.division as f64;
        Self {
            track_iterator: input_file.tracks[track_index].events.iter(),
            current_tempo_in_micro_seconds_per_beat: (MICROSECONDS_PER_MINUTE
                / DEFAULT_BEATS_PER_MINUTE)
                as f64,
            ticks_per_beat,
        }
    }
}

impl<'a> Iterator for RimdMidiReader<'a> {
    type Item = DeltaEvent<RawMidiEvent>;

    fn next(&mut self) -> Option<DeltaEvent<RawMidiEvent>> {
        let mut microseconds_since_previous_event = 0.0;

        while let Some(event) = self.track_iterator.next() {
            // `vtime` is in ticks.
            microseconds_since_previous_event +=
                (event.vtime as f64) / self.ticks_per_microsecond();

            match &event.event {
                Event::Midi(mm) => {
                    if let Some(raw_event) = RawMidiEvent::try_new(&mm.data) {
                        return Some(DeltaEvent {
                            microseconds_since_previous_event: microseconds_since_previous_event
                                as u64,
                            event: raw_event,
                        });
                    } else {
                        unimplemented!("better error handling for this error case");
                    }
                }
                Event::Meta(MetaEvent {
                    command: MetaCommand::TempoSetting,
                    data,
                    ..
                }) => {
                    if data.len() != 3 {
                        unimplemented!("better error handling for this error case");
                    }
                    self.current_tempo_in_micro_seconds_per_beat =
                        data[2] as f64 + 255.0 * (data[1] as f64 + (255.0 * data[0] as f64));
                }
                Event::Meta(_) => {}
            }
        }
        None
    }
}

pub struct RimdMidiWriter {
    writer: SMFBuilder,
    current_time_in_microseconds: u64,
    current_tempo_in_micro_seconds_per_beat: u32,
    ticks_per_beat: u16,
}

impl RimdMidiWriter {
    pub fn new(current_tempo_in_micro_seconds_per_beat: u32, ticks_per_beat: u16) -> Self {
        assert_eq!(ticks_per_beat & 0b10000000_00000000, 0);
        let mut writer = SMFBuilder::new();
        writer.add_track();
        writer.add_meta_abs(
            0,
            0,
            MetaEvent::tempo_setting(current_tempo_in_micro_seconds_per_beat),
        );
        Self {
            writer,
            current_time_in_microseconds: 0,
            current_tempo_in_micro_seconds_per_beat,
            ticks_per_beat,
        }
    }

    fn ticks_per_microsecond(&self) -> f64 {
        (self.ticks_per_beat as f64) / (self.current_tempo_in_micro_seconds_per_beat as f64)
    }

    pub fn get_smf(self) -> SMF {
        let Self {
            writer,
            ticks_per_beat,
            ..
        } = self;
        let mut result = writer.result();
        result.division = ticks_per_beat as i16;
        result
    }
}

impl MidiWriter for RimdMidiWriter {
    fn write_event(&mut self, event: DeltaEvent<RawMidiEvent>) {
        let DeltaEvent {
            microseconds_since_previous_event,
            event,
        } = event;
        self.current_time_in_microseconds += microseconds_since_previous_event;
        let current_time_in_ticks =
            self.current_time_in_microseconds as f64 / self.ticks_per_microsecond();
        self.writer.add_midi_abs(
            0,
            current_time_in_ticks as u64,
            MidiMessage::from_bytes(Vec::from(&event.data()[..])),
        );
    }
}