miami 0.1.3

Minimal dependency MIDI file format parser and writer
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

//! Chunk Definitions for parsed types and type headers

use header::{HeaderChunk, InvalidFormat};
use track::TrackChunk;

use crate::{
    chunk::chunk_types::{HEADER_CHUNK, TRACK_DATA_CHUNK},
    writer::MidiWriteable,
    Chunk,
};

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

pub mod chunk_types;
pub mod header;
pub mod track;

/// Represents a parsed MIDI Chunk with its associated data.
/// A parsed chunk is classified based on its type, such as header or track.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum ParsedChunk {
    /// A header chunk
    Header(HeaderChunk),
    /// A track chunk,
    Track(TrackChunk),
}

impl MidiWriteable for ParsedChunk {
    fn to_midi_bytes(self) -> Vec<u8> {
        let val: (Chunk, Vec<u8>) = self.into();
        val.to_midi_bytes()
    }
}

/// Error type for attempting to parse from a raw chunk to a parsed one
#[derive(Debug)]
pub enum ChunkParseError {
    /// Invalid format in parsing a header
    InvalidFormat(InvalidFormat),
    /// Type tag is not registered
    UnknownType,
    /// Random todo during debugging
    Todo(&'static str),
    /// Error parsing track
    TrackParseError(track::TrackError),
}

impl core::error::Error for ChunkParseError {}
impl core::fmt::Display for ChunkParseError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::InvalidFormat(_) => write![f, "Invalid Format Specified"],
            Self::UnknownType => write![f, "Unknown Chunk Type"],
            Self::Todo(s) => write![f, "Development TODO: {s}"],
            Self::TrackParseError(_) => write![f, "Track parsing error"],
        }
    }
}
impl From<InvalidFormat> for ChunkParseError {
    fn from(f: InvalidFormat) -> Self {
        Self::InvalidFormat(f)
    }
}
impl From<track::TrackError> for ChunkParseError {
    fn from(f: track::TrackError) -> Self {
        Self::TrackParseError(f)
    }
}

impl From<ParsedChunk> for (Chunk, Vec<u8>) {
    fn from(value: ParsedChunk) -> Self {
        match value {
            ParsedChunk::Header(header) => {
                let bytes = header.to_midi_bytes();
                let chunk = Chunk {
                    chunk_type: HEADER_CHUNK,
                    length: bytes.len() as u32,
                };

                (chunk, bytes)
            }
            ParsedChunk::Track(track) => {
                let mut bytes = vec![];

                for mtrk_event in track.mtrk_events {
                    bytes.extend(mtrk_event.to_midi_bytes().iter());
                }

                let chunk = Chunk {
                    chunk_type: TRACK_DATA_CHUNK,
                    length: bytes.len() as u32,
                };
                (chunk, bytes)
            }
        }
    }
}

impl TryFrom<(Chunk, Vec<u8>)> for ParsedChunk {
    type Error = ChunkParseError;
    fn try_from(value: (Chunk, Vec<u8>)) -> Result<Self, Self::Error> {
        let (chunk, data) = value;

        match chunk.chunk_type {
            HEADER_CHUNK => {
                if chunk.len() == 6 {
                    let format = u16::from_be_bytes([data[0], data[1]]);
                    let ntrk = u16::from_be_bytes([data[2], data[3]]);
                    let division = u16::from_be_bytes([data[4], data[5]]);
                    let parsed = HeaderChunk::try_from((format, ntrk, division))?;
                    Ok(ParsedChunk::Header(parsed))
                } else {
                    Err(ChunkParseError::InvalidFormat(InvalidFormat))
                }
            }

            TRACK_DATA_CHUNK => {
                let parsed = TrackChunk::try_from(data)?;
                Ok(ParsedChunk::Track(parsed))
            }

            _ => Err(ChunkParseError::UnknownType),
        }
    }
}