midix 3.2.0

MIDI structures designed for humans
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

use std::fmt::Debug;

use crate::prelude::*;

#[doc = r#"
Identifies some event emitted by a track in a MIDI file.

# Overview
All MIDI track events have an associated `delta_time`. This
identifies the amount of time since the previous event.

"#]
#[derive(Clone, PartialEq)]
pub struct TrackEvent<'a> {
    /// Variable length quantity
    /// Delta-ticks is in some fraction of a beat
    /// (or a second, for recording a track with SMPTE times),
    /// as specified in the header chunk.
    delta_ticks: u32,
    event: TrackMessage<'a>,
}

impl Debug for TrackEvent<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Track Event {{ delta_time: 0x{:02X}, event: {:?} }}",
            self.delta_ticks, self.event
        )
    }
}

impl<'a> TrackEvent<'a> {
    /// Create a new event with a given time
    pub fn new(delta_time: u32, event: TrackMessage<'a>) -> Self {
        Self {
            delta_ticks: delta_time,
            event,
        }
    }

    /// Update the running status here.
    pub(crate) fn read<'slc, 'r, R>(
        reader: &'r mut Reader<R>,
        running_status: &mut Option<u8>,
    ) -> ReadResult<Self>
    where
        R: MidiSource<'slc>,
        'slc: 'a,
    {
        let delta_ticks = crate::reader::decode_varlen(reader)?;

        let next_event = reader.read_next()?;

        let message = match next_event {
            0xF0 => {
                let mut data = reader.read_varlen_slice()?;
                if !data.is_empty() {
                    //discard the last 0xF7
                    data.truncate(1);
                }
                TrackMessage::SystemExclusive(SystemExclusiveMessage::new(data))
            }
            0xFF => TrackMessage::Meta(MetaMessage::read(reader)?),
            byte => {
                //status if the byte has a leading 1, otherwise it's
                //a running status

                let status = if byte >> 7 == 1 {
                    *running_status = Some(byte);
                    byte
                } else if let Some(prev_status) = running_status {
                    //Hack: decrementing the buffer position should not be done
                    reader.state.decrement_offset(1);
                    *prev_status
                } else {
                    return Err(inv_data(reader, "Invalid MIDI event triggered"));
                };
                let status = StatusByte::try_from(status).unwrap();

                TrackMessage::ChannelVoice(ChannelVoiceMessage::read(status, reader)?)
            }
        };

        Ok(Self {
            delta_ticks,
            event: message,
        })
    }

    /// Get the difference in ticks from the last event
    ///
    /// The actual value should be interpreted by the MIDI file's
    /// [`Timing`] event.
    pub fn delta_ticks(&self) -> u32 {
        self.delta_ticks
    }

    /// Get a refrence to the message for the track event
    pub fn event(&self) -> &TrackMessage<'a> {
        &self.event
    }

    /// Get the owned inner track event
    pub fn into_event(self) -> TrackMessage<'a> {
        self.event
    }
}