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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
//! Crate-wide error type.
//!
//! The library never panics on malformed input. Anything that arrives from a MIDI
//! port or a `.syx` file is untrusted and every rejection carries the offending
//! value so a host application can log something actionable.
use core::fmt;
/// Convenience alias for results produced by this crate.
pub type Result<T, E = Error> = core::result::Result<T, E>;
/// Everything that can go wrong while parsing or building `DeepMind` messages.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Error {
/// A device ID byte was neither `0..=15` nor `0x7F`.
InvalidDeviceId(u8),
/// A bank index was 8 or greater.
BankOutOfRange(u8),
/// A bank letter was outside `A..=H`.
BankLetter(char),
/// A program number was 128 or greater.
ProgramOutOfRange(u8),
/// A run of programs ended before it started.
EmptyRun {
/// Program number the run was to start at.
first: u8,
/// Program number it was to end at, which was lower.
last: u8,
},
/// A user pattern number was 32 or greater.
PatternOutOfRange(u8),
/// A MIDI channel was 16 or greater.
ChannelOutOfRange(u8),
/// A parameter offset was 242 or greater, so it names no parameter.
ParameterOutOfRange(u8),
/// An effect engine number was outside the four the synthesizer has.
EngineOutOfRange(u8),
/// A value was outside the range its parameter accepts.
ValueOutOfRange {
/// Offset of the parameter the value was meant for.
parameter: u8,
/// The value offered.
value: u16,
/// Highest value the parameter accepts. The lowest is always zero.
max: u16,
},
/// A dump carried a comms protocol version this build does not understand.
UnsupportedProtocolVersion(u8),
/// Program data was not as long as its comms protocol version calls for.
ProgramLength {
/// Bytes the version's program data occupies.
expected: usize,
/// Bytes that were offered.
found: usize,
},
/// A message that carries no program was read as one.
NotAProgramDump(u8),
/// A program name was longer than sixteen characters.
ProgramNameTooLong(usize),
/// A program name held a character the display has no glyph for.
ProgramNameCharacter(char),
/// A `SysEx` frame did not start with `F0` or did not end with `F7`.
Unframed,
/// A `SysEx` frame was too short to carry the header every message has.
ShortFrame(usize),
/// A `SysEx` frame carried another manufacturer's or another model's ID.
Foreign {
/// The three manufacturer ID bytes the frame carried.
manufacturer: [u8; 3],
/// The model ID byte the frame carried.
model: u8,
},
/// A command byte no documented message uses.
UnknownCommand(u8),
/// A payload was not the length its command requires.
PayloadLength {
/// Command byte of the message being parsed.
command: u8,
/// Payload length the command calls for.
expected: usize,
/// Payload length the frame actually carried.
found: usize,
},
/// A packed run ended in a high-bit byte with no data bytes to apply it to.
PackedRunLength(usize),
/// A byte meant for the inside of a `SysEx` frame had its high bit set.
NotSevenBit(u8),
/// An output buffer was too small for what had to be written into it.
BufferTooSmall {
/// Bytes the operation needed.
needed: usize,
/// Bytes the caller supplied.
available: usize,
},
/// A `SysEx` frame was longer than the decoder's buffer, and was dropped.
SysExTooLong(usize),
/// A status byte arrived before a `SysEx` frame's `F7`, ending it early.
SysExInterrupted,
/// An interface byte was neither MIDI (0), USB (1) nor Wi-Fi (2).
InvalidInterface(u8),
/// A universal `SysEx` frame was not a device inquiry request.
NotAnInquiryRequest,
/// A universal `SysEx` frame was not a `DeepMind` device inquiry response.
NotAnInquiryResponse,
/// An edit was made before any program was known, so nothing said what
/// changed.
ProgramNotKnown,
/// More was queued to send than the outbound queue had room for.
QueueFull {
/// Items the operation needed room for.
needed: usize,
/// Items the queue had room for.
available: usize,
},
}
impl fmt::Display for Error {
#[expect(clippy::too_many_lines, reason = "one arm per variant")]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidDeviceId(byte) => {
write!(
f,
"invalid device ID {byte:#04X}, expected 0x00..=0x0F or 0x7F"
)
}
Self::BankOutOfRange(index) => write!(f, "bank {index} out of range, expected 0..=7"),
Self::BankLetter(letter) => write!(f, "bank {letter:?} is not a letter A..=H"),
Self::ProgramOutOfRange(number) => {
write!(f, "program {number} out of range, expected 0..=127")
}
Self::EmptyRun { first, last } => {
write!(
f,
"run from program {first} to {last} ends before it starts"
)
}
Self::PatternOutOfRange(number) => {
write!(f, "pattern {number} out of range, expected 0..=31")
}
Self::ChannelOutOfRange(channel) => {
write!(f, "MIDI channel {channel} out of range, expected 0..=15")
}
Self::ParameterOutOfRange(offset) => {
write!(
f,
"parameter offset {offset} out of range, expected 0..=241"
)
}
Self::EngineOutOfRange(engine) => {
write!(f, "effect engine {engine} out of range, expected 1..=4")
}
Self::ValueOutOfRange {
parameter,
value,
max,
} => write!(
f,
"value {value} out of range for parameter {parameter}, expected 0..={max}"
),
Self::UnsupportedProtocolVersion(version) => {
write!(
f,
"unsupported comms protocol version {version}, expected 6 or 7"
)
}
Self::ProgramLength { expected, found } => {
write!(f, "program data of {found} bytes, expected {expected}")
}
Self::NotAProgramDump(command) => {
write!(f, "command {command:#04X} carries no program")
}
Self::ProgramNameTooLong(len) => {
write!(f, "program name of {len} characters, expected 16 or fewer")
}
Self::ProgramNameCharacter(character) => write!(
f,
"program name holds {character:?}, expected printable ASCII"
),
Self::Unframed => f.write_str("not a SysEx frame: expected F0 ... F7"),
Self::ShortFrame(len) => {
write!(
f,
"SysEx frame of {len} bytes is too short to carry a header"
)
}
Self::Foreign {
manufacturer: [a, b, c],
model,
} => write!(
f,
"SysEx frame for manufacturer {a:02X} {b:02X} {c:02X} model {model:02X}, \
not Behringer 00 20 32 model 20"
),
Self::UnknownCommand(command) => {
write!(f, "unknown SysEx command {command:#04X}")
}
Self::PayloadLength {
command,
expected,
found,
} => write!(
f,
"command {command:#04X} carries a {found} byte payload, expected {expected}"
),
Self::PackedRunLength(len) => write!(
f,
"packed run of {len} bytes ends in a high-bit byte with no data"
),
Self::NotSevenBit(byte) => {
write!(f, "byte {byte:#04X} cannot travel inside a SysEx frame")
}
Self::BufferTooSmall { needed, available } => {
write!(f, "buffer of {available} bytes is too small, need {needed}")
}
Self::SysExTooLong(capacity) => {
write!(f, "SysEx frame longer than the {capacity} byte buffer")
}
Self::SysExInterrupted => {
f.write_str("SysEx frame interrupted by a status byte before its F7")
}
Self::InvalidInterface(byte) => write!(
f,
"invalid interface {byte}, expected 0 (MIDI), 1 (USB) or 2 (Wi-Fi)"
),
Self::NotAnInquiryRequest => f.write_str("not a device inquiry request"),
Self::NotAnInquiryResponse => f.write_str("not a DeepMind device inquiry response"),
Self::ProgramNotKnown => f.write_str("no program known yet, nothing to edit"),
Self::QueueFull { needed, available } => {
write!(f, "queue has room for {available} items, need {needed}")
}
}
}
}
impl core::error::Error for Error {}