midi_toolkit/events/
event_variants.rs

1use crate::events::encode_var_length_value;
2use crate::io::MIDIWriteError;
3use crate::sequence::event::Delta;
4
5use super::event::Event;
6use super::{ChannelEvent, KeyEvent, MIDIEvent, MIDINum, PlaybackEvent, SerializeEvent};
7use derive::{MIDIEvent, NewEvent};
8
9#[derive(Debug, Clone, Copy, PartialEq)]
10pub struct MIDIColor {
11    pub r: u8,
12    pub g: u8,
13    pub b: u8,
14    pub a: u8,
15}
16
17#[derive(Debug, Clone, PartialEq, Copy)]
18pub enum TextEventKind {
19    TextEvent = 1,
20    CopyrightNotice = 2,
21    TrackName = 3,
22    InstrumentName = 4,
23    Lyric = 5,
24    Marker = 6,
25    CuePoint = 7,
26    ProgramName = 8,
27    DeviceName = 9,
28    Undefined = 10,
29    MetaEvent = 0x7F,
30}
31
32impl TextEventKind {
33    pub fn from_val(val: u8) -> TextEventKind {
34        match val {
35            1 => TextEventKind::TextEvent,
36            2 => TextEventKind::CopyrightNotice,
37            3 => TextEventKind::TrackName,
38            4 => TextEventKind::InstrumentName,
39            5 => TextEventKind::Lyric,
40            6 => TextEventKind::Marker,
41            7 => TextEventKind::CuePoint,
42            8 => TextEventKind::ProgramName,
43            9 => TextEventKind::DeviceName,
44            10 => TextEventKind::Undefined,
45            0x7F => TextEventKind::MetaEvent,
46            _ => TextEventKind::Undefined,
47        }
48    }
49}
50
51#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
52#[playback]
53pub struct NoteOnEvent {
54    #[channel]
55    pub channel: u8,
56    #[key]
57    pub key: u8,
58    pub velocity: u8,
59}
60
61impl SerializeEvent for NoteOnEvent {
62    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
63        let event = [0x90 | self.channel, self.key, self.velocity];
64        Ok(buf.write(&event)?)
65    }
66}
67
68impl PlaybackEvent for NoteOnEvent {
69    fn as_u32(&self) -> u32 {
70        (0x90 | self.channel as u32) | (self.key as u32) << 8 | (self.velocity as u32) << 16
71    }
72}
73
74#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
75#[playback]
76pub struct NoteOffEvent {
77    #[channel]
78    pub channel: u8,
79    #[key]
80    pub key: u8,
81}
82
83impl SerializeEvent for NoteOffEvent {
84    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
85        let event = [0x80 | self.channel, self.key, 0];
86        Ok(buf.write(&event)?)
87    }
88}
89
90impl PlaybackEvent for NoteOffEvent {
91    fn as_u32(&self) -> u32 {
92        (0x80 | self.channel as u32) | (self.key as u32) << 8
93    }
94}
95
96#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
97#[playback]
98pub struct PolyphonicKeyPressureEvent {
99    #[channel]
100    pub channel: u8,
101    #[key]
102    pub key: u8,
103    pub velocity: u8,
104}
105
106impl SerializeEvent for PolyphonicKeyPressureEvent {
107    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
108        let event = [0xA0 | self.channel, self.key, self.velocity];
109        Ok(buf.write(&event)?)
110    }
111}
112
113impl PlaybackEvent for PolyphonicKeyPressureEvent {
114    fn as_u32(&self) -> u32 {
115        (0xA0 | self.channel as u32) | (self.key as u32) << 8 | (self.velocity as u32) << 16
116    }
117}
118
119#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
120#[playback]
121pub struct ControlChangeEvent {
122    #[channel]
123    pub channel: u8,
124    pub controller: u8,
125    pub value: u8,
126}
127
128impl SerializeEvent for ControlChangeEvent {
129    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
130        let event = [0xB0 | self.channel, self.controller, self.value];
131        Ok(buf.write(&event)?)
132    }
133}
134
135impl PlaybackEvent for ControlChangeEvent {
136    fn as_u32(&self) -> u32 {
137        (0xB0 | self.channel as u32) | (self.controller as u32) << 8 | (self.value as u32) << 16
138    }
139}
140
141#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
142#[playback]
143pub struct ProgramChangeEvent {
144    #[channel]
145    pub channel: u8,
146    pub program: u8,
147}
148
149impl SerializeEvent for ProgramChangeEvent {
150    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
151        let event = [0xC0 | self.channel, self.program];
152        Ok(buf.write(&event)?)
153    }
154}
155
156impl PlaybackEvent for ProgramChangeEvent {
157    fn as_u32(&self) -> u32 {
158        (0xC0 | self.channel as u32) | (self.program as u32) << 8
159    }
160}
161
162#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
163#[playback]
164pub struct ChannelPressureEvent {
165    #[channel]
166    pub channel: u8,
167    pub pressure: u8,
168}
169
170impl SerializeEvent for ChannelPressureEvent {
171    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
172        let event = [0xD0 | self.channel, self.pressure];
173        Ok(buf.write(&event)?)
174    }
175}
176
177impl PlaybackEvent for ChannelPressureEvent {
178    fn as_u32(&self) -> u32 {
179        (0xD0 | self.channel as u32) | (self.pressure as u32) << 8
180    }
181}
182
183#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
184#[playback]
185pub struct PitchWheelChangeEvent {
186    #[channel]
187    pub channel: u8,
188    pub pitch: i16,
189}
190
191impl SerializeEvent for PitchWheelChangeEvent {
192    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
193        let value = self.pitch + 8192;
194        let event = [
195            0xE0 | self.channel,
196            (value & 0x7F) as u8,
197            ((value >> 7) & 0x7F) as u8,
198        ];
199        Ok(buf.write(&event)?)
200    }
201}
202
203impl PlaybackEvent for PitchWheelChangeEvent {
204    fn as_u32(&self) -> u32 {
205        let value = self.pitch + 8192;
206        let val1 = value & 0x7F;
207        let val2 = (value >> 7) & 0x7F;
208        (0xE0 | self.channel as u32) | (val1 as u32) << 8 | (val2 as u32) << 16
209    }
210}
211
212#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
213pub struct SystemExclusiveMessageEvent {
214    pub data: Vec<u8>,
215}
216
217impl SerializeEvent for SystemExclusiveMessageEvent {
218    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
219        let mut vec = Vec::with_capacity(self.data.len() + 2);
220        vec.push(0xF0u8);
221        for v in self.data.iter() {
222            vec.push(*v);
223        }
224        vec.push(0xF7u8);
225        Ok(buf.write(&vec)?)
226    }
227}
228
229#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
230pub struct UndefinedEvent {
231    pub event: u8,
232}
233
234impl SerializeEvent for UndefinedEvent {
235    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
236        let event = [self.event];
237        Ok(buf.write(&event)?)
238    }
239}
240
241#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
242pub struct SongPositionPointerEvent {
243    pub position: u16,
244}
245
246impl SerializeEvent for SongPositionPointerEvent {
247    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
248        let event = [
249            0xF2,
250            (self.position & 0x7F) as u8,
251            ((self.position >> 7) & 0x7F) as u8,
252        ];
253        Ok(buf.write(&event)?)
254    }
255}
256
257#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
258pub struct SongSelectEvent {
259    pub song: u8,
260}
261
262impl SerializeEvent for SongSelectEvent {
263    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
264        let event = [0xF3, self.song];
265        Ok(buf.write(&event)?)
266    }
267}
268
269#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
270pub struct TuneRequestEvent {}
271
272impl SerializeEvent for TuneRequestEvent {
273    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
274        let event = [0xF6];
275        Ok(buf.write(&event)?)
276    }
277}
278
279#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
280pub struct EndOfExclusiveEvent {}
281
282impl SerializeEvent for EndOfExclusiveEvent {
283    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
284        let event = [0xF7];
285        Ok(buf.write(&event)?)
286    }
287}
288
289#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
290pub struct TrackStartEvent {}
291
292impl SerializeEvent for TrackStartEvent {
293    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
294        let event = [0xFF, 0x00, 0x02];
295        Ok(buf.write(&event)?)
296    }
297}
298
299#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
300pub struct TextEvent {
301    pub kind: TextEventKind,
302    pub bytes: Vec<u8>,
303}
304
305impl SerializeEvent for TextEvent {
306    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
307        let mut vec = Vec::with_capacity(self.bytes.len() + 2);
308        vec.push(0xFF);
309        vec.push(self.kind as u8);
310        vec.append(&mut encode_var_length_value(self.bytes.len() as u64));
311        for v in self.bytes.iter() {
312            vec.push(*v);
313        }
314        Ok(buf.write(&vec)?)
315    }
316}
317
318#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
319pub struct UnknownMetaEvent {
320    pub kind: u8,
321    pub bytes: Vec<u8>,
322}
323
324impl SerializeEvent for UnknownMetaEvent {
325    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
326        let mut vec = Vec::with_capacity(self.bytes.len() + 2);
327        vec.push(0xFF);
328        vec.push(self.kind);
329        vec.append(&mut encode_var_length_value(self.bytes.len() as u64));
330        for v in self.bytes.iter() {
331            vec.push(*v);
332        }
333        Ok(buf.write(&vec)?)
334    }
335}
336
337#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
338pub struct ColorEvent {
339    pub channel: u8,
340    pub col: MIDIColor,
341    pub col2: Option<MIDIColor>,
342}
343
344impl SerializeEvent for ColorEvent {
345    fn serialize_event<T: std::io::Write>(&self, _buf: &mut T) -> Result<usize, MIDIWriteError> {
346        todo!();
347    }
348}
349
350#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
351pub struct ChannelPrefixEvent {
352    #[channel]
353    pub channel: u8,
354}
355
356impl SerializeEvent for ChannelPrefixEvent {
357    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
358        let event = [0xFF, 0x20, 0x01, self.channel];
359        Ok(buf.write(&event)?)
360    }
361}
362
363#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
364pub struct MIDIPortEvent {
365    #[channel]
366    pub channel: u8,
367}
368
369impl SerializeEvent for MIDIPortEvent {
370    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
371        let event = [0xFF, 0x21, 0x01, self.channel];
372        Ok(buf.write(&event)?)
373    }
374}
375
376#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
377pub struct TempoEvent {
378    pub tempo: u32,
379}
380
381impl SerializeEvent for TempoEvent {
382    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
383        let event = [
384            0xFF,
385            0x51,
386            0x03,
387            ((self.tempo >> 16) & 0xFF) as u8,
388            ((self.tempo >> 8) & 0xFF) as u8,
389            (self.tempo & 0xFF) as u8,
390        ];
391        Ok(buf.write(&event)?)
392    }
393}
394
395#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
396pub struct SMPTEOffsetEvent {
397    pub hours: u8,
398    pub minutes: u8,
399    pub seconds: u8,
400    pub frames: u8,
401    pub fractional_frames: u8,
402}
403
404impl SerializeEvent for SMPTEOffsetEvent {
405    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
406        let event = [
407            0xFF,
408            0x54,
409            0x05,
410            self.hours,
411            self.minutes,
412            self.seconds,
413            self.frames,
414            self.fractional_frames,
415        ];
416        Ok(buf.write(&event)?)
417    }
418}
419
420#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
421pub struct TimeSignatureEvent {
422    pub numerator: u8,
423    pub denominator: u8,
424    pub ticks_per_click: u8,
425    pub bb: u8,
426}
427
428impl SerializeEvent for TimeSignatureEvent {
429    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
430        let event = [
431            0xFF,
432            0x58,
433            0x04,
434            self.numerator,
435            self.denominator,
436            self.ticks_per_click,
437            self.bb,
438        ];
439        Ok(buf.write(&event)?)
440    }
441}
442
443#[derive(Debug, MIDIEvent, Clone, NewEvent, PartialEq)]
444pub struct KeySignatureEvent {
445    pub sf: u8,
446    pub mi: u8,
447}
448
449impl SerializeEvent for KeySignatureEvent {
450    fn serialize_event<T: std::io::Write>(&self, buf: &mut T) -> Result<usize, MIDIWriteError> {
451        let event = [0xFF, 0x59, 0x02, self.sf, self.mi];
452        Ok(buf.write(&event)?)
453    }
454}
midi_toolkit/events/event_variants.rs

midi_toolkit/events/
event_variants.rs
