1#![allow(dead_code)]
2
3#[derive(Debug, PartialEq, Eq)]
4enum DataType {
5 None,
6 Rpn,
7 Nrpn,
8}
9
10#[derive(Debug)]
11#[non_exhaustive]
12pub(crate) struct Channel {
13 pub(crate) is_percussion_channel: bool,
14
15 bank_number: i32,
16 patch_number: i32,
17
18 modulation: i16,
19 volume: i16,
20 pan: i16,
21 expression: i16,
22 hold_pedal: bool,
23
24 reverb_send: u8,
25 chorus_send: u8,
26
27 rpn: i16,
28 pitch_bend_range: i16,
29 coarse_tune: i16,
30 fine_tune: i16,
31
32 pitch_bend: f32,
33
34 last_data_type: DataType,
35}
36
37impl Channel {
38 pub(crate) fn new(is_percussion_channel: bool) -> Self {
39 let mut channel = Self {
40 is_percussion_channel,
41 bank_number: 0,
42 patch_number: 0,
43 modulation: 0,
44 volume: 0,
45 pan: 0,
46 expression: 0,
47 hold_pedal: false,
48 reverb_send: 0,
49 chorus_send: 0,
50 rpn: 0,
51 pitch_bend_range: 0,
52 coarse_tune: 0,
53 fine_tune: 0,
54 pitch_bend: 0_f32,
55 last_data_type: DataType::None,
56 };
57
58 channel.reset();
59
60 channel
61 }
62
63 pub(crate) fn reset(&mut self) {
64 self.bank_number = if self.is_percussion_channel { 128 } else { 0 };
65 self.patch_number = 0;
66
67 self.modulation = 0;
68 self.volume = 100 << 7;
69 self.pan = 64 << 7;
70 self.expression = 127 << 7;
71 self.hold_pedal = false;
72
73 self.reverb_send = 40;
74 self.chorus_send = 0;
75
76 self.rpn = -1;
77 self.pitch_bend_range = 2 << 7;
78 self.coarse_tune = 0;
79 self.fine_tune = 8192;
80
81 self.pitch_bend = 0_f32;
82 }
83
84 pub(crate) fn reset_all_controllers(&mut self) {
85 self.modulation = 0;
86 self.expression = 127 << 7;
87 self.hold_pedal = false;
88
89 self.rpn = -1;
90
91 self.pitch_bend = 0_f32;
92 }
93
94 pub(crate) fn set_bank(&mut self, value: i32) {
95 self.bank_number = value;
96
97 if self.is_percussion_channel {
98 self.bank_number += 128;
99 }
100 }
101
102 pub(crate) fn set_patch(&mut self, value: i32) {
103 self.patch_number = value;
104 }
105
106 pub(crate) fn set_modulation_coarse(&mut self, value: i32) {
107 self.modulation = (self.modulation & 0x7F) | (value << 7) as i16;
108 }
109
110 pub(crate) fn set_modulation_fine(&mut self, value: i32) {
111 self.modulation = (((self.modulation as i32) & 0xFF80) | value) as i16;
112 }
113
114 pub(crate) fn set_volume_coarse(&mut self, value: i32) {
115 self.volume = (self.volume & 0x7F) | (value << 7) as i16;
116 }
117
118 pub(crate) fn set_volume_fine(&mut self, value: i32) {
119 self.volume = (((self.volume as i32) & 0xFF80) | value) as i16;
120 }
121
122 pub(crate) fn set_pan_coarse(&mut self, value: i32) {
123 self.pan = (self.pan & 0x7F) | (value << 7) as i16;
124 }
125
126 pub(crate) fn set_pan_fine(&mut self, value: i32) {
127 self.pan = (((self.pan as i32) & 0xFF80) | value) as i16;
128 }
129
130 pub(crate) fn set_expression_coarse(&mut self, value: i32) {
131 self.expression = (self.expression & 0x7F) | (value << 7) as i16;
132 }
133
134 pub(crate) fn set_expression_fine(&mut self, value: i32) {
135 self.expression = (((self.expression as i32) & 0xFF80) | value) as i16;
136 }
137
138 pub(crate) fn set_hold_pedal(&mut self, value: i32) {
139 self.hold_pedal = value >= 64;
140 }
141
142 pub(crate) fn set_reverb_send(&mut self, value: i32) {
143 self.reverb_send = value as u8;
144 }
145
146 pub(crate) fn set_chorus_send(&mut self, value: i32) {
147 self.chorus_send = value as u8;
148 }
149
150 pub(crate) fn set_rpn_coarse(&mut self, value: i32) {
151 self.rpn = (self.rpn & 0x7F) | (value << 7) as i16;
152 self.last_data_type = DataType::Rpn;
153 }
154
155 pub(crate) fn set_rpn_fine(&mut self, value: i32) {
156 self.rpn = (((self.rpn as i32) & 0xFF80) | value) as i16;
157 self.last_data_type = DataType::Rpn;
158 }
159
160 pub(crate) fn set_nrpn_coarse(&mut self, _value: i32) {
161 self.last_data_type = DataType::Nrpn;
162 }
163
164 pub(crate) fn set_nrpn_fine(&mut self, _value: i32) {
165 self.last_data_type = DataType::Nrpn;
166 }
167
168 pub(crate) fn data_entry_coarse(&mut self, value: i32) {
169 if self.last_data_type != DataType::Rpn {
170 return;
171 }
172
173 if self.rpn == 0 {
174 self.pitch_bend_range = (self.pitch_bend_range & 0x7F) | (value << 7) as i16;
175 } else if self.rpn == 1 {
176 self.fine_tune = (self.fine_tune & 0x7F) | (value << 7) as i16;
177 } else if self.rpn == 2 {
178 self.coarse_tune = (value - 64) as i16;
179 }
180 }
181
182 pub(crate) fn data_entry_fine(&mut self, value: i32) {
183 if self.last_data_type != DataType::Rpn {
184 return;
185 }
186
187 if self.rpn == 0 {
188 self.pitch_bend_range = (((self.pitch_bend_range as i32) & 0xFF80) | value) as i16;
189 } else if self.rpn == 1 {
190 self.fine_tune = (((self.fine_tune as i32) & 0xFF80) | value) as i16;
191 }
192 }
193
194 pub(crate) fn set_pitch_bend(&mut self, value1: i32, value2: i32) {
195 self.pitch_bend = (1_f32 / 8192_f32) * ((value1 | (value2 << 7)) - 8192) as f32;
196 }
197
198 pub(crate) fn get_bank_number(&self) -> i32 {
199 self.bank_number
200 }
201
202 pub(crate) fn get_patch_number(&self) -> i32 {
203 self.patch_number
204 }
205
206 pub(crate) fn get_modulation(&self) -> f32 {
207 (50_f32 / 16383_f32) * self.modulation as f32
208 }
209
210 pub(crate) fn get_volume(&self) -> f32 {
211 (1_f32 / 16383_f32) * self.volume as f32
212 }
213
214 pub(crate) fn get_pan(&self) -> f32 {
215 (100_f32 / 16383_f32) * self.pan as f32 - 50_f32
216 }
217
218 pub(crate) fn get_expression(&self) -> f32 {
219 (1_f32 / 16383_f32) * self.expression as f32
220 }
221
222 pub(crate) fn get_hold_pedal(&self) -> bool {
223 self.hold_pedal
224 }
225
226 pub(crate) fn get_reverb_send(&self) -> f32 {
227 (1_f32 / 127_f32) * self.reverb_send as f32
228 }
229
230 pub(crate) fn get_chorus_send(&self) -> f32 {
231 (1_f32 / 127_f32) * self.chorus_send as f32
232 }
233
234 pub(crate) fn get_pitch_bend_range(&self) -> f32 {
235 (self.pitch_bend_range >> 7) as f32 + 0.01_f32 * (self.pitch_bend_range & 0x7F) as f32
236 }
237
238 pub(crate) fn get_tune(&self) -> f32 {
239 self.coarse_tune as f32 + (1_f32 / 8192_f32) * (self.fine_tune - 8192) as f32
240 }
241
242 pub(crate) fn get_pitch_bend(&self) -> f32 {
243 self.get_pitch_bend_range() * self.pitch_bend
244 }
245}