1use crate::{reader::*, Version};
2
3#[derive(PartialEq, Debug, Clone)]
4pub struct MidiSettings {
5 pub receive_sync: bool,
6 pub receive_transport: u8,
7 pub send_sync: bool,
8 pub send_transport: u8,
9 pub record_note_channel: u8,
10 pub record_note_velocity: bool,
11 pub record_note_delay_kill_commands: u8,
12 pub control_map_channel: u8,
13 pub song_row_cue_channel: u8,
14 pub track_input_channel: [u8; 8],
15 pub track_input_intrument: [u8; 8],
16 pub track_input_program_change: bool,
17 pub track_input_mode: u8,
18}
19
20impl TryFrom<&mut Reader> for MidiSettings {
21 type Error = ParseError;
22
23 fn try_from(reader: &mut Reader) -> M8Result<Self> {
24 Ok(Self {
25 receive_sync: reader.read_bool(),
26 receive_transport: reader.read(),
27 send_sync: reader.read_bool(),
28 send_transport: reader.read(),
29 record_note_channel: reader.read(),
30 record_note_velocity: reader.read_bool(),
31 record_note_delay_kill_commands: reader.read(),
32 control_map_channel: reader.read(),
33 song_row_cue_channel: reader.read(),
34 track_input_channel: reader.read_bytes(8).try_into().unwrap(),
35 track_input_intrument: reader.read_bytes(8).try_into().unwrap(),
36 track_input_program_change: reader.read_bool(),
37 track_input_mode: reader.read(),
38 })
39 }
40}
41
42#[derive(PartialEq, Debug, Clone)]
43pub struct MixerSettings {
44 pub master_volume: u8,
45 pub master_limit: u8,
46 pub track_volume: [u8; 8],
47 pub chorus_volume: u8,
48 pub delay_volume: u8,
49 pub reverb_volume: u8,
50 pub analog_input: AnalogInputSettings,
51 pub usb_input: InputMixerSettings,
52 pub dj_filter: u8,
53 pub dj_peak: u8,
54 pub dj_filter_type: u8,
55}
56
57impl MixerSettings {
58 pub(crate) fn from_reader(reader: &mut Reader) -> M8Result<Self> {
59 let master_volume = reader.read();
60 let master_limit = reader.read();
61 let track_volume: [u8; 8] = reader.read_bytes(8).try_into().unwrap();
62 let chorus_volume = reader.read();
63 let delay_volume = reader.read();
64 let reverb_volume = reader.read();
65 let analog_input_volume = (reader.read(), reader.read());
66 let usb_input_volume = reader.read();
67 let analog_input_chorus = (reader.read(), reader.read());
68 let analog_input_delay = (reader.read(), reader.read());
69 let analog_input_reverb = (reader.read(), reader.read());
70 let usb_input_chorus = reader.read();
71 let usb_input_delay = reader.read();
72 let usb_input_reverb = reader.read();
73
74 let analog_input_l = InputMixerSettings {
75 volume: analog_input_volume.0,
76 chorus: analog_input_chorus.0,
77 delay: analog_input_delay.0,
78 reverb: analog_input_reverb.0,
79 };
80
81 let analog_input = if analog_input_volume.1 == 255 {
82 AnalogInputSettings::Stereo(analog_input_l)
83 } else {
84 let analog_input_r = InputMixerSettings {
85 volume: analog_input_volume.0,
86 chorus: analog_input_chorus.0,
87 delay: analog_input_delay.0,
88 reverb: analog_input_reverb.0,
89 };
90 AnalogInputSettings::DualMono((analog_input_l, analog_input_r))
91 };
92 let usb_input = InputMixerSettings {
93 volume: usb_input_volume,
94 chorus: usb_input_chorus,
95 delay: usb_input_delay,
96 reverb: usb_input_reverb,
97 };
98
99 let dj_filter = reader.read();
100 let dj_peak = reader.read();
101 let dj_filter_type = reader.read();
102
103 reader.read_bytes(4); Ok(Self {
105 master_volume,
106 master_limit,
107 track_volume,
108 chorus_volume,
109 delay_volume,
110 reverb_volume,
111 analog_input,
112 usb_input,
113 dj_filter,
114 dj_peak,
115 dj_filter_type,
116 })
117 }
118}
119
120#[derive(PartialEq, Debug, Clone)]
121pub struct InputMixerSettings {
122 pub volume: u8,
123 pub chorus: u8,
124 pub delay: u8,
125 pub reverb: u8,
126}
127
128#[derive(PartialEq, Debug, Clone)]
129pub enum AnalogInputSettings {
130 Stereo(InputMixerSettings),
131 DualMono((InputMixerSettings, InputMixerSettings)),
132}
133
134#[derive(PartialEq, Debug, Clone)]
135pub struct EffectsSettings {
136 pub chorus_mod_depth: u8,
137 pub chorus_mod_freq: u8,
138 pub chorus_reverb_send: u8,
139
140 pub delay_hp: u8,
141 pub delay_lp: u8,
142 pub delay_time_l: u8,
143 pub delay_time_r: u8,
144 pub delay_feedback: u8,
145 pub delay_width: u8,
146 pub delay_reverb_send: u8,
147
148 pub reverb_hp: u8,
149 pub reverb_lp: u8,
150 pub reverb_size: u8,
151 pub reverb_damping: u8,
152 pub reverb_mod_depth: u8,
153 pub reverb_mod_freq: u8,
154 pub reverb_width: u8,
155}
156impl EffectsSettings {
157 pub(crate) fn from_reader(reader: &mut Reader, version: Version) -> M8Result<Self> {
158 let chorus_mod_depth = reader.read();
159 let chorus_mod_freq = reader.read();
160 let chorus_reverb_send = reader.read();
161 reader.read_bytes(3); let (delay_hp, delay_lp) = if version.at_least(4, 0) {
165 (0, 0)
166 } else {
167 (reader.read(), reader.read())
168 };
169
170 let delay_time_l = reader.read();
171 let delay_time_r = reader.read();
172 let delay_feedback = reader.read();
173 let delay_width = reader.read();
174 let delay_reverb_send = reader.read();
175 reader.read_bytes(1); let (reverb_hp, reverb_lp) = if version.at_least(4, 0) {
179 (0, 0)
180 } else {
181 (reader.read(), reader.read())
182 };
183
184 let reverb_size = reader.read();
185 let reverb_damping = reader.read();
186 let reverb_mod_depth = reader.read();
187 let reverb_mod_freq = reader.read();
188 let reverb_width = reader.read();
189
190 Ok(Self {
191 chorus_mod_depth,
192 chorus_mod_freq,
193 chorus_reverb_send,
194
195 delay_hp,
196 delay_lp,
197 delay_time_l,
198 delay_time_r,
199 delay_feedback,
200 delay_width,
201 delay_reverb_send,
202
203 reverb_hp,
204 reverb_lp,
205 reverb_size,
206 reverb_damping,
207 reverb_mod_depth,
208 reverb_mod_freq,
209 reverb_width,
210 })
211 }
212}
213
214#[derive(PartialEq, Debug, Clone)]
215pub struct MidiMapping {
216 pub channel: u8,
217 pub control_number: u8,
218 pub value: u8,
219 pub typ: u8,
220 pub param_index: u8,
221 pub min_value: u8,
222 pub max_value: u8,
223}
224
225impl MidiMapping {
226 pub(crate) fn from_reader(reader: &mut Reader) -> M8Result<Self> {
227 Ok(Self {
228 channel: reader.read(),
229 control_number: reader.read(),
230 value: reader.read(),
231 typ: reader.read(),
232 param_index: reader.read(),
233 min_value: reader.read(),
234 max_value: reader.read(),
235 })
236 }
237
238 pub fn empty(&self) -> bool {
239 self.channel == 0
240 }
241}