1#![expect(
12 clippy::too_many_lines,
13 clippy::match_same_arms,
14 reason = "generated tables, not logic"
15)]
16
17use core::fmt;
18
19use super::Program;
20use crate::param::{DEFAULT_FIRMWARE, ParamId, TableId};
21use crate::sysex::inquiry::Version;
22
23pub const NAME_OFFSET: u8 = 223;
25
26pub const NAME_LEN: usize = 17;
28
29pub static NAME_PARAMETERS: [ParamId; NAME_LEN] = [
41 ParamId::ProgramNameChar1,
42 ParamId::ProgramNameChar2,
43 ParamId::ProgramNameChar3,
44 ParamId::ProgramNameChar4,
45 ParamId::ProgramNameChar5,
46 ParamId::ProgramNameChar6,
47 ParamId::ProgramNameChar7,
48 ParamId::ProgramNameChar8,
49 ParamId::ProgramNameChar9,
50 ParamId::ProgramNameChar10,
51 ParamId::ProgramNameChar11,
52 ParamId::ProgramNameChar12,
53 ParamId::ProgramNameChar13,
54 ParamId::ProgramNameChar14,
55 ParamId::ProgramNameChar15,
56 ParamId::ProgramNameChar16,
57 ParamId::ProgramNameChar17,
58];
59
60#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
66#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
67#[non_exhaustive]
68pub enum ArpMode {
69 Up,
71 Down,
73 UpAndDown,
75 UpInv,
77 DownInv,
79 UpAndDownInv,
81 UpAlt,
83 DownAlt,
85 Random,
87 AsPlayed,
89 Chord,
91}
92
93impl ArpMode {
94 pub const TABLE: TableId = TableId::ArpMode;
96
97 pub const ALL: &'static [Self] = &[
99 Self::Up,
100 Self::Down,
101 Self::UpAndDown,
102 Self::UpInv,
103 Self::DownInv,
104 Self::UpAndDownInv,
105 Self::UpAlt,
106 Self::DownAlt,
107 Self::Random,
108 Self::AsPlayed,
109 Self::Chord,
110 ];
111
112 #[must_use]
116 pub const fn from_raw(raw: u8) -> Option<Self> {
117 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
118 }
119
120 #[must_use]
126 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
127 match raw {
128 0 => Some(Self::Up),
129 1 => Some(Self::Down),
130 2 => Some(Self::UpAndDown),
131 3 => Some(Self::UpInv),
132 4 => Some(Self::DownInv),
133 5 => Some(Self::UpAndDownInv),
134 6 => Some(Self::UpAlt),
135 7 => Some(Self::DownAlt),
136 8 => Some(Self::Random),
137 9 => Some(Self::AsPlayed),
138 10 => Some(Self::Chord),
139 _ => None,
140 }
141 }
142
143 #[must_use]
145 pub const fn raw(self) -> u8 {
146 match self {
147 Self::Up => 0,
148 Self::Down => 1,
149 Self::UpAndDown => 2,
150 Self::UpInv => 3,
151 Self::DownInv => 4,
152 Self::UpAndDownInv => 5,
153 Self::UpAlt => 6,
154 Self::DownAlt => 7,
155 Self::Random => 8,
156 Self::AsPlayed => 9,
157 Self::Chord => 10,
158 }
159 }
160
161 #[must_use]
166 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
167 Some(self.raw())
168 }
169
170 #[must_use]
173 pub fn name(self) -> &'static str {
174 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
175 }
176
177 #[must_use]
184 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
185 let raw = self.raw_for(firmware)?;
186 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
187 }
188}
189
190impl fmt::Display for ArpMode {
191 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
192 f.write_str(self.name())
193 }
194}
195
196#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
202#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
203#[non_exhaustive]
204pub enum EnvelopeTrigger {
205 Key,
207 Lfo1,
209 Lfo2,
211 Loop,
213 ControlSequencerStep,
215}
216
217impl EnvelopeTrigger {
218 pub const TABLE: TableId = TableId::EnvelopeTrigger;
220
221 pub const ALL: &'static [Self] = &[
223 Self::Key,
224 Self::Lfo1,
225 Self::Lfo2,
226 Self::Loop,
227 Self::ControlSequencerStep,
228 ];
229
230 #[must_use]
234 pub const fn from_raw(raw: u8) -> Option<Self> {
235 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
236 }
237
238 #[must_use]
244 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
245 match raw {
246 0 => Some(Self::Key),
247 1 => Some(Self::Lfo1),
248 2 => Some(Self::Lfo2),
249 3 => Some(Self::Loop),
250 4 => Some(Self::ControlSequencerStep),
251 _ => None,
252 }
253 }
254
255 #[must_use]
257 pub const fn raw(self) -> u8 {
258 match self {
259 Self::Key => 0,
260 Self::Lfo1 => 1,
261 Self::Lfo2 => 2,
262 Self::Loop => 3,
263 Self::ControlSequencerStep => 4,
264 }
265 }
266
267 #[must_use]
272 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
273 Some(self.raw())
274 }
275
276 #[must_use]
279 pub fn name(self) -> &'static str {
280 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
281 }
282
283 #[must_use]
290 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
291 let raw = self.raw_for(firmware)?;
292 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
293 }
294}
295
296impl fmt::Display for EnvelopeTrigger {
297 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
298 f.write_str(self.name())
299 }
300}
301
302#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
308#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
309#[non_exhaustive]
310pub enum FxMode {
311 Insert,
313 Send,
315 Bypass,
317}
318
319impl FxMode {
320 pub const TABLE: TableId = TableId::FxMode;
322
323 pub const ALL: &'static [Self] = &[Self::Insert, Self::Send, Self::Bypass];
325
326 #[must_use]
330 pub const fn from_raw(raw: u8) -> Option<Self> {
331 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
332 }
333
334 #[must_use]
340 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
341 match raw {
342 0 => Some(Self::Insert),
343 1 => Some(Self::Send),
344 2 => Some(Self::Bypass),
345 _ => None,
346 }
347 }
348
349 #[must_use]
351 pub const fn raw(self) -> u8 {
352 match self {
353 Self::Insert => 0,
354 Self::Send => 1,
355 Self::Bypass => 2,
356 }
357 }
358
359 #[must_use]
364 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
365 Some(self.raw())
366 }
367
368 #[must_use]
371 pub fn name(self) -> &'static str {
372 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
373 }
374
375 #[must_use]
382 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
383 let raw = self.raw_for(firmware)?;
384 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
385 }
386}
387
388impl fmt::Display for FxMode {
389 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
390 f.write_str(self.name())
391 }
392}
393
394#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
400#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
401#[non_exhaustive]
402pub enum FxRouting {
403 Serial1234,
405 Parallel12Serial34,
407 Parallel12Parallel34,
409 Parallel1234,
411 Parallel123Serial4,
413 Serial12Parallel34,
415 Serial1Parallel234,
417 ParallelSerial1234,
419 Serial34Feedback412,
421 Serial4Feedback4123,
423}
424
425impl FxRouting {
426 pub const TABLE: TableId = TableId::FxRouting;
428
429 pub const ALL: &'static [Self] = &[
431 Self::Serial1234,
432 Self::Parallel12Serial34,
433 Self::Parallel12Parallel34,
434 Self::Parallel1234,
435 Self::Parallel123Serial4,
436 Self::Serial12Parallel34,
437 Self::Serial1Parallel234,
438 Self::ParallelSerial1234,
439 Self::Serial34Feedback412,
440 Self::Serial4Feedback4123,
441 ];
442
443 #[must_use]
447 pub const fn from_raw(raw: u8) -> Option<Self> {
448 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
449 }
450
451 #[must_use]
457 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
458 match raw {
459 0 => Some(Self::Serial1234),
460 1 => Some(Self::Parallel12Serial34),
461 2 => Some(Self::Parallel12Parallel34),
462 3 => Some(Self::Parallel1234),
463 4 => Some(Self::Parallel123Serial4),
464 5 => Some(Self::Serial12Parallel34),
465 6 => Some(Self::Serial1Parallel234),
466 7 => Some(Self::ParallelSerial1234),
467 8 => Some(Self::Serial34Feedback412),
468 9 => Some(Self::Serial4Feedback4123),
469 _ => None,
470 }
471 }
472
473 #[must_use]
475 pub const fn raw(self) -> u8 {
476 match self {
477 Self::Serial1234 => 0,
478 Self::Parallel12Serial34 => 1,
479 Self::Parallel12Parallel34 => 2,
480 Self::Parallel1234 => 3,
481 Self::Parallel123Serial4 => 4,
482 Self::Serial12Parallel34 => 5,
483 Self::Serial1Parallel234 => 6,
484 Self::ParallelSerial1234 => 7,
485 Self::Serial34Feedback412 => 8,
486 Self::Serial4Feedback4123 => 9,
487 }
488 }
489
490 #[must_use]
495 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
496 Some(self.raw())
497 }
498
499 #[must_use]
502 pub fn name(self) -> &'static str {
503 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
504 }
505
506 #[must_use]
513 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
514 let raw = self.raw_for(firmware)?;
515 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
516 }
517}
518
519impl fmt::Display for FxRouting {
520 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
521 f.write_str(self.name())
522 }
523}
524
525#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
535#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
536#[non_exhaustive]
537pub enum FxType {
538 TcDeepVrb,
540 AmbVerb,
542 RoomRev,
544 VintageRev,
546 HallRev,
548 ChamberRev,
550 PlateRev,
552 RichPltRev,
554 GatedRev,
556 Reverse,
558 ChorusVerb,
560 DelayVerb,
562 FlangVerb,
564 MidasEq,
566 Enhancer,
568 FairComp,
570 MulBndDist,
572 RackAmp,
574 EdisonEx1,
576 AutoPan,
578 NoiseGate,
580 Delay,
582 ThreeTapDelay,
584 FourTapDelay,
586 TRayDelay,
588 DecimDelay,
590 ModDlyRev,
592 Chorus,
594 ChorusD,
596 Flanger,
598 Phaser,
600 MoodFilter,
602 DualPitch,
604 VintagePitch,
606 RotarySpkr,
608}
609
610impl FxType {
611 pub const TABLE: TableId = TableId::FxType;
613
614 pub const ALL: &'static [Self] = &[
616 Self::TcDeepVrb,
617 Self::AmbVerb,
618 Self::RoomRev,
619 Self::VintageRev,
620 Self::HallRev,
621 Self::ChamberRev,
622 Self::PlateRev,
623 Self::RichPltRev,
624 Self::GatedRev,
625 Self::Reverse,
626 Self::ChorusVerb,
627 Self::DelayVerb,
628 Self::FlangVerb,
629 Self::MidasEq,
630 Self::Enhancer,
631 Self::FairComp,
632 Self::MulBndDist,
633 Self::RackAmp,
634 Self::EdisonEx1,
635 Self::AutoPan,
636 Self::NoiseGate,
637 Self::Delay,
638 Self::ThreeTapDelay,
639 Self::FourTapDelay,
640 Self::TRayDelay,
641 Self::DecimDelay,
642 Self::ModDlyRev,
643 Self::Chorus,
644 Self::ChorusD,
645 Self::Flanger,
646 Self::Phaser,
647 Self::MoodFilter,
648 Self::DualPitch,
649 Self::VintagePitch,
650 Self::RotarySpkr,
651 ];
652
653 #[must_use]
657 pub const fn from_raw(raw: u8) -> Option<Self> {
658 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
659 }
660
661 #[must_use]
667 pub const fn from_raw_for(raw: u8, firmware: Version) -> Option<Self> {
668 if firmware.at_least(1, 1) {
669 match raw {
670 0 => Some(Self::TcDeepVrb),
671 1 => Some(Self::AmbVerb),
672 2 => Some(Self::RoomRev),
673 3 => Some(Self::VintageRev),
674 4 => Some(Self::HallRev),
675 5 => Some(Self::ChamberRev),
676 6 => Some(Self::PlateRev),
677 7 => Some(Self::RichPltRev),
678 8 => Some(Self::GatedRev),
679 9 => Some(Self::Reverse),
680 10 => Some(Self::ChorusVerb),
681 11 => Some(Self::DelayVerb),
682 12 => Some(Self::FlangVerb),
683 13 => Some(Self::MidasEq),
684 14 => Some(Self::Enhancer),
685 15 => Some(Self::FairComp),
686 16 => Some(Self::MulBndDist),
687 17 => Some(Self::RackAmp),
688 18 => Some(Self::EdisonEx1),
689 19 => Some(Self::AutoPan),
690 20 => Some(Self::NoiseGate),
691 21 => Some(Self::Delay),
692 22 => Some(Self::ThreeTapDelay),
693 23 => Some(Self::FourTapDelay),
694 24 => Some(Self::TRayDelay),
695 25 => Some(Self::DecimDelay),
696 26 => Some(Self::ModDlyRev),
697 27 => Some(Self::Chorus),
698 28 => Some(Self::ChorusD),
699 29 => Some(Self::Flanger),
700 30 => Some(Self::Phaser),
701 31 => Some(Self::MoodFilter),
702 32 => Some(Self::DualPitch),
703 33 => Some(Self::VintagePitch),
704 34 => Some(Self::RotarySpkr),
705 _ => None,
706 }
707 } else {
708 match raw {
709 0 => Some(Self::TcDeepVrb),
710 1 => Some(Self::AmbVerb),
711 2 => Some(Self::RoomRev),
712 3 => Some(Self::VintageRev),
713 4 => Some(Self::HallRev),
714 5 => Some(Self::ChamberRev),
715 6 => Some(Self::PlateRev),
716 7 => Some(Self::RichPltRev),
717 8 => Some(Self::GatedRev),
718 9 => Some(Self::Reverse),
719 10 => Some(Self::ChorusVerb),
720 11 => Some(Self::DelayVerb),
721 12 => Some(Self::FlangVerb),
722 13 => Some(Self::MidasEq),
723 14 => Some(Self::Enhancer),
724 15 => Some(Self::FairComp),
725 16 => Some(Self::MulBndDist),
726 17 => Some(Self::RackAmp),
727 18 => Some(Self::EdisonEx1),
728 19 => Some(Self::AutoPan),
729 20 => Some(Self::NoiseGate),
730 21 => Some(Self::Delay),
731 22 => Some(Self::ThreeTapDelay),
732 23 => Some(Self::FourTapDelay),
733 24 => Some(Self::TRayDelay),
734 25 => Some(Self::DecimDelay),
735 26 => Some(Self::ModDlyRev),
736 27 => Some(Self::Chorus),
737 28 => Some(Self::ChorusD),
738 29 => Some(Self::Flanger),
739 30 => Some(Self::Phaser),
740 31 => Some(Self::MoodFilter),
741 32 => Some(Self::DualPitch),
742 33 => Some(Self::RotarySpkr),
743 _ => None,
744 }
745 }
746 }
747
748 #[must_use]
750 pub const fn raw(self) -> u8 {
751 match self {
752 Self::TcDeepVrb => 0,
753 Self::AmbVerb => 1,
754 Self::RoomRev => 2,
755 Self::VintageRev => 3,
756 Self::HallRev => 4,
757 Self::ChamberRev => 5,
758 Self::PlateRev => 6,
759 Self::RichPltRev => 7,
760 Self::GatedRev => 8,
761 Self::Reverse => 9,
762 Self::ChorusVerb => 10,
763 Self::DelayVerb => 11,
764 Self::FlangVerb => 12,
765 Self::MidasEq => 13,
766 Self::Enhancer => 14,
767 Self::FairComp => 15,
768 Self::MulBndDist => 16,
769 Self::RackAmp => 17,
770 Self::EdisonEx1 => 18,
771 Self::AutoPan => 19,
772 Self::NoiseGate => 20,
773 Self::Delay => 21,
774 Self::ThreeTapDelay => 22,
775 Self::FourTapDelay => 23,
776 Self::TRayDelay => 24,
777 Self::DecimDelay => 25,
778 Self::ModDlyRev => 26,
779 Self::Chorus => 27,
780 Self::ChorusD => 28,
781 Self::Flanger => 29,
782 Self::Phaser => 30,
783 Self::MoodFilter => 31,
784 Self::DualPitch => 32,
785 Self::VintagePitch => 33,
786 Self::RotarySpkr => 34,
787 }
788 }
789
790 #[must_use]
795 pub const fn raw_for(self, firmware: Version) -> Option<u8> {
796 if firmware.at_least(1, 1) {
797 match self {
798 Self::TcDeepVrb => Some(0),
799 Self::AmbVerb => Some(1),
800 Self::RoomRev => Some(2),
801 Self::VintageRev => Some(3),
802 Self::HallRev => Some(4),
803 Self::ChamberRev => Some(5),
804 Self::PlateRev => Some(6),
805 Self::RichPltRev => Some(7),
806 Self::GatedRev => Some(8),
807 Self::Reverse => Some(9),
808 Self::ChorusVerb => Some(10),
809 Self::DelayVerb => Some(11),
810 Self::FlangVerb => Some(12),
811 Self::MidasEq => Some(13),
812 Self::Enhancer => Some(14),
813 Self::FairComp => Some(15),
814 Self::MulBndDist => Some(16),
815 Self::RackAmp => Some(17),
816 Self::EdisonEx1 => Some(18),
817 Self::AutoPan => Some(19),
818 Self::NoiseGate => Some(20),
819 Self::Delay => Some(21),
820 Self::ThreeTapDelay => Some(22),
821 Self::FourTapDelay => Some(23),
822 Self::TRayDelay => Some(24),
823 Self::DecimDelay => Some(25),
824 Self::ModDlyRev => Some(26),
825 Self::Chorus => Some(27),
826 Self::ChorusD => Some(28),
827 Self::Flanger => Some(29),
828 Self::Phaser => Some(30),
829 Self::MoodFilter => Some(31),
830 Self::DualPitch => Some(32),
831 Self::VintagePitch => Some(33),
832 Self::RotarySpkr => Some(34),
833 }
834 } else {
835 match self {
836 Self::TcDeepVrb => Some(0),
837 Self::AmbVerb => Some(1),
838 Self::RoomRev => Some(2),
839 Self::VintageRev => Some(3),
840 Self::HallRev => Some(4),
841 Self::ChamberRev => Some(5),
842 Self::PlateRev => Some(6),
843 Self::RichPltRev => Some(7),
844 Self::GatedRev => Some(8),
845 Self::Reverse => Some(9),
846 Self::ChorusVerb => Some(10),
847 Self::DelayVerb => Some(11),
848 Self::FlangVerb => Some(12),
849 Self::MidasEq => Some(13),
850 Self::Enhancer => Some(14),
851 Self::FairComp => Some(15),
852 Self::MulBndDist => Some(16),
853 Self::RackAmp => Some(17),
854 Self::EdisonEx1 => Some(18),
855 Self::AutoPan => Some(19),
856 Self::NoiseGate => Some(20),
857 Self::Delay => Some(21),
858 Self::ThreeTapDelay => Some(22),
859 Self::FourTapDelay => Some(23),
860 Self::TRayDelay => Some(24),
861 Self::DecimDelay => Some(25),
862 Self::ModDlyRev => Some(26),
863 Self::Chorus => Some(27),
864 Self::ChorusD => Some(28),
865 Self::Flanger => Some(29),
866 Self::Phaser => Some(30),
867 Self::MoodFilter => Some(31),
868 Self::DualPitch => Some(32),
869 Self::VintagePitch => None,
870 Self::RotarySpkr => Some(33),
871 }
872 }
873 }
874
875 #[must_use]
878 pub fn name(self) -> &'static str {
879 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
880 }
881
882 #[must_use]
889 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
890 let raw = self.raw_for(firmware)?;
891 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
892 }
893}
894
895impl fmt::Display for FxType {
896 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
897 f.write_str(self.name())
898 }
899}
900
901#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
907#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
908#[non_exhaustive]
909pub enum KeyAssignMode {
910 Mono,
912 ReTrigger,
914 Legato,
916 OneShot,
918}
919
920impl KeyAssignMode {
921 pub const TABLE: TableId = TableId::KeyAssignMode;
923
924 pub const ALL: &'static [Self] = &[Self::Mono, Self::ReTrigger, Self::Legato, Self::OneShot];
926
927 #[must_use]
931 pub const fn from_raw(raw: u8) -> Option<Self> {
932 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
933 }
934
935 #[must_use]
941 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
942 match raw {
943 0 => Some(Self::Mono),
944 1 => Some(Self::ReTrigger),
945 2 => Some(Self::Legato),
946 3 => Some(Self::OneShot),
947 _ => None,
948 }
949 }
950
951 #[must_use]
953 pub const fn raw(self) -> u8 {
954 match self {
955 Self::Mono => 0,
956 Self::ReTrigger => 1,
957 Self::Legato => 2,
958 Self::OneShot => 3,
959 }
960 }
961
962 #[must_use]
967 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
968 Some(self.raw())
969 }
970
971 #[must_use]
974 pub fn name(self) -> &'static str {
975 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
976 }
977
978 #[must_use]
985 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
986 let raw = self.raw_for(firmware)?;
987 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
988 }
989}
990
991impl fmt::Display for KeyAssignMode {
992 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
993 f.write_str(self.name())
994 }
995}
996
997#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1003#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1004#[non_exhaustive]
1005pub enum LfoShape {
1006 Sine,
1008 Triangle,
1010 Square,
1012 RampUp,
1014 RampDown,
1016 SampleAndHold,
1018 SampleAndGlide,
1020}
1021
1022impl LfoShape {
1023 pub const TABLE: TableId = TableId::LfoShape;
1025
1026 pub const ALL: &'static [Self] = &[
1028 Self::Sine,
1029 Self::Triangle,
1030 Self::Square,
1031 Self::RampUp,
1032 Self::RampDown,
1033 Self::SampleAndHold,
1034 Self::SampleAndGlide,
1035 ];
1036
1037 #[must_use]
1041 pub const fn from_raw(raw: u8) -> Option<Self> {
1042 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
1043 }
1044
1045 #[must_use]
1051 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
1052 match raw {
1053 0 => Some(Self::Sine),
1054 1 => Some(Self::Triangle),
1055 2 => Some(Self::Square),
1056 3 => Some(Self::RampUp),
1057 4 => Some(Self::RampDown),
1058 5 => Some(Self::SampleAndHold),
1059 6 => Some(Self::SampleAndGlide),
1060 _ => None,
1061 }
1062 }
1063
1064 #[must_use]
1066 pub const fn raw(self) -> u8 {
1067 match self {
1068 Self::Sine => 0,
1069 Self::Triangle => 1,
1070 Self::Square => 2,
1071 Self::RampUp => 3,
1072 Self::RampDown => 4,
1073 Self::SampleAndHold => 5,
1074 Self::SampleAndGlide => 6,
1075 }
1076 }
1077
1078 #[must_use]
1083 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
1084 Some(self.raw())
1085 }
1086
1087 #[must_use]
1090 pub fn name(self) -> &'static str {
1091 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
1092 }
1093
1094 #[must_use]
1101 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
1102 let raw = self.raw_for(firmware)?;
1103 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
1104 }
1105}
1106
1107impl fmt::Display for LfoShape {
1108 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1109 f.write_str(self.name())
1110 }
1111}
1112
1113#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1123#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1124#[non_exhaustive]
1125pub enum ModDestination {
1126 Off,
1128 Lfo1Rate,
1130 Lfo1Delay,
1132 Lfo1Slew,
1134 Lfo1Shape,
1136 Lfo2Rate,
1138 Lfo2Delay,
1140 Lfo2Slew,
1142 Lfo2Shape,
1144 Osc12Pit,
1146 Osc12Fine,
1148 Osc1Pitch,
1150 Osc1Fine,
1152 Osc2Pitch,
1154 Osc2Fine,
1156 Osc1PmDep,
1158 PwmDepth,
1160 TmodDepth,
1162 Osc2PmDep,
1164 PortaTime,
1166 VcfFreq,
1168 VcfRes,
1170 VcfEnv,
1172 VcfLfo,
1174 EnvRates,
1176 AllAttack,
1178 AllDecay,
1180 AllSus,
1182 AllRel,
1184 Env1Rates,
1186 Env2Rates,
1188 Env3Rates,
1190 Env1CurveS,
1192 Env2CurveS,
1194 Env3CurveS,
1196 Env1Attack,
1198 Env1Decay,
1200 Env1Sus,
1202 Env1Rel,
1204 Env1AtCur,
1206 Env1DcyCur,
1208 Env1SuScur,
1210 Env1RelCur,
1212 Env2Attack,
1214 Env2Decay,
1216 Env2Sus,
1218 Env2Rel,
1220 Env2AtCur,
1222 Env2DcyCur,
1224 Env2SuScur,
1226 Env2RelCur,
1228 Env3Attack,
1230 Env3Decay,
1232 Env3Sus,
1234 Env3Rel,
1236 Env3AtCur,
1238 Env3DcyCur,
1240 Env3SuScur,
1242 Env3RelCur,
1244 VcaAll,
1246 VcaActive,
1248 VcaEnvDep,
1250 PanSpread,
1252 VcaPan,
1254 Osc2Lvl,
1256 NoiseLvl,
1258 HpFreq,
1260 UniDetune,
1262 OscDrift,
1264 ParamDrift,
1266 DriftRate,
1268 ArpGate,
1270 SeqSlew,
1272 Mod1Dep,
1274 Mod2Dep,
1276 Mod3Dep,
1278 Mod4Dep,
1280 Mod5Dep,
1282 Mod6Dep,
1284 Mod7Dep,
1286 Mod8Dep,
1288 Fx1Param1,
1290 Fx1Param2,
1292 Fx1Param3,
1294 Fx1Param4,
1296 Fx1Param5,
1298 Fx1Param6,
1300 Fx1Param7,
1302 Fx1Param8,
1304 Fx1Param9,
1306 Fx1Param10,
1308 Fx1Param11,
1310 Fx1Param12,
1312 Fx2Param1,
1314 Fx2Param2,
1316 Fx2Param3,
1318 Fx2Param4,
1320 Fx2Param5,
1322 Fx2Param6,
1324 Fx2Param7,
1326 Fx2Param8,
1328 Fx2Param9,
1330 Fx2Param10,
1332 Fx2Param11,
1334 Fx2Param12,
1336 Fx3Param1,
1338 Fx3Param2,
1340 Fx3Param3,
1342 Fx3Param4,
1344 Fx3Param5,
1346 Fx3Param6,
1348 Fx3Param7,
1350 Fx3Param8,
1352 Fx3Param9,
1354 Fx3Param10,
1356 Fx3Param11,
1358 Fx3Param12,
1360 Fx4Param1,
1362 Fx4Param2,
1364 Fx4Param3,
1366 Fx4Param4,
1368 Fx4Param5,
1370 Fx4Param6,
1372 Fx4Param7,
1374 Fx4Param8,
1376 Fx4Param9,
1378 Fx4Param10,
1380 Fx4Param11,
1382 Fx4Param12,
1384 Fx1Level,
1386 Fx2Level,
1388 Fx3Level,
1390 Fx4Level,
1392}
1393
1394impl ModDestination {
1395 pub const TABLE: TableId = TableId::ModDestination;
1397
1398 pub const ALL: &'static [Self] = &[
1400 Self::Off,
1401 Self::Lfo1Rate,
1402 Self::Lfo1Delay,
1403 Self::Lfo1Slew,
1404 Self::Lfo1Shape,
1405 Self::Lfo2Rate,
1406 Self::Lfo2Delay,
1407 Self::Lfo2Slew,
1408 Self::Lfo2Shape,
1409 Self::Osc12Pit,
1410 Self::Osc12Fine,
1411 Self::Osc1Pitch,
1412 Self::Osc1Fine,
1413 Self::Osc2Pitch,
1414 Self::Osc2Fine,
1415 Self::Osc1PmDep,
1416 Self::PwmDepth,
1417 Self::TmodDepth,
1418 Self::Osc2PmDep,
1419 Self::PortaTime,
1420 Self::VcfFreq,
1421 Self::VcfRes,
1422 Self::VcfEnv,
1423 Self::VcfLfo,
1424 Self::EnvRates,
1425 Self::AllAttack,
1426 Self::AllDecay,
1427 Self::AllSus,
1428 Self::AllRel,
1429 Self::Env1Rates,
1430 Self::Env2Rates,
1431 Self::Env3Rates,
1432 Self::Env1CurveS,
1433 Self::Env2CurveS,
1434 Self::Env3CurveS,
1435 Self::Env1Attack,
1436 Self::Env1Decay,
1437 Self::Env1Sus,
1438 Self::Env1Rel,
1439 Self::Env1AtCur,
1440 Self::Env1DcyCur,
1441 Self::Env1SuScur,
1442 Self::Env1RelCur,
1443 Self::Env2Attack,
1444 Self::Env2Decay,
1445 Self::Env2Sus,
1446 Self::Env2Rel,
1447 Self::Env2AtCur,
1448 Self::Env2DcyCur,
1449 Self::Env2SuScur,
1450 Self::Env2RelCur,
1451 Self::Env3Attack,
1452 Self::Env3Decay,
1453 Self::Env3Sus,
1454 Self::Env3Rel,
1455 Self::Env3AtCur,
1456 Self::Env3DcyCur,
1457 Self::Env3SuScur,
1458 Self::Env3RelCur,
1459 Self::VcaAll,
1460 Self::VcaActive,
1461 Self::VcaEnvDep,
1462 Self::PanSpread,
1463 Self::VcaPan,
1464 Self::Osc2Lvl,
1465 Self::NoiseLvl,
1466 Self::HpFreq,
1467 Self::UniDetune,
1468 Self::OscDrift,
1469 Self::ParamDrift,
1470 Self::DriftRate,
1471 Self::ArpGate,
1472 Self::SeqSlew,
1473 Self::Mod1Dep,
1474 Self::Mod2Dep,
1475 Self::Mod3Dep,
1476 Self::Mod4Dep,
1477 Self::Mod5Dep,
1478 Self::Mod6Dep,
1479 Self::Mod7Dep,
1480 Self::Mod8Dep,
1481 Self::Fx1Param1,
1482 Self::Fx1Param2,
1483 Self::Fx1Param3,
1484 Self::Fx1Param4,
1485 Self::Fx1Param5,
1486 Self::Fx1Param6,
1487 Self::Fx1Param7,
1488 Self::Fx1Param8,
1489 Self::Fx1Param9,
1490 Self::Fx1Param10,
1491 Self::Fx1Param11,
1492 Self::Fx1Param12,
1493 Self::Fx2Param1,
1494 Self::Fx2Param2,
1495 Self::Fx2Param3,
1496 Self::Fx2Param4,
1497 Self::Fx2Param5,
1498 Self::Fx2Param6,
1499 Self::Fx2Param7,
1500 Self::Fx2Param8,
1501 Self::Fx2Param9,
1502 Self::Fx2Param10,
1503 Self::Fx2Param11,
1504 Self::Fx2Param12,
1505 Self::Fx3Param1,
1506 Self::Fx3Param2,
1507 Self::Fx3Param3,
1508 Self::Fx3Param4,
1509 Self::Fx3Param5,
1510 Self::Fx3Param6,
1511 Self::Fx3Param7,
1512 Self::Fx3Param8,
1513 Self::Fx3Param9,
1514 Self::Fx3Param10,
1515 Self::Fx3Param11,
1516 Self::Fx3Param12,
1517 Self::Fx4Param1,
1518 Self::Fx4Param2,
1519 Self::Fx4Param3,
1520 Self::Fx4Param4,
1521 Self::Fx4Param5,
1522 Self::Fx4Param6,
1523 Self::Fx4Param7,
1524 Self::Fx4Param8,
1525 Self::Fx4Param9,
1526 Self::Fx4Param10,
1527 Self::Fx4Param11,
1528 Self::Fx4Param12,
1529 Self::Fx1Level,
1530 Self::Fx2Level,
1531 Self::Fx3Level,
1532 Self::Fx4Level,
1533 ];
1534
1535 #[must_use]
1539 pub const fn from_raw(raw: u8) -> Option<Self> {
1540 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
1541 }
1542
1543 #[must_use]
1549 pub const fn from_raw_for(raw: u8, firmware: Version) -> Option<Self> {
1550 if firmware.at_least(1, 1) {
1551 match raw {
1552 0 => Some(Self::Off),
1553 1 => Some(Self::Lfo1Rate),
1554 2 => Some(Self::Lfo1Delay),
1555 3 => Some(Self::Lfo1Slew),
1556 4 => Some(Self::Lfo1Shape),
1557 5 => Some(Self::Lfo2Rate),
1558 6 => Some(Self::Lfo2Delay),
1559 7 => Some(Self::Lfo2Slew),
1560 8 => Some(Self::Lfo2Shape),
1561 9 => Some(Self::Osc12Pit),
1562 10 => Some(Self::Osc12Fine),
1563 11 => Some(Self::Osc1Pitch),
1564 12 => Some(Self::Osc1Fine),
1565 13 => Some(Self::Osc2Pitch),
1566 14 => Some(Self::Osc2Fine),
1567 15 => Some(Self::Osc1PmDep),
1568 16 => Some(Self::PwmDepth),
1569 17 => Some(Self::TmodDepth),
1570 18 => Some(Self::Osc2PmDep),
1571 19 => Some(Self::PortaTime),
1572 20 => Some(Self::VcfFreq),
1573 21 => Some(Self::VcfRes),
1574 22 => Some(Self::VcfEnv),
1575 23 => Some(Self::VcfLfo),
1576 24 => Some(Self::EnvRates),
1577 25 => Some(Self::AllAttack),
1578 26 => Some(Self::AllDecay),
1579 27 => Some(Self::AllSus),
1580 28 => Some(Self::AllRel),
1581 29 => Some(Self::Env1Rates),
1582 30 => Some(Self::Env2Rates),
1583 31 => Some(Self::Env3Rates),
1584 32 => Some(Self::Env1CurveS),
1585 33 => Some(Self::Env2CurveS),
1586 34 => Some(Self::Env3CurveS),
1587 35 => Some(Self::Env1Attack),
1588 36 => Some(Self::Env1Decay),
1589 37 => Some(Self::Env1Sus),
1590 38 => Some(Self::Env1Rel),
1591 39 => Some(Self::Env1AtCur),
1592 40 => Some(Self::Env1DcyCur),
1593 41 => Some(Self::Env1SuScur),
1594 42 => Some(Self::Env1RelCur),
1595 43 => Some(Self::Env2Attack),
1596 44 => Some(Self::Env2Decay),
1597 45 => Some(Self::Env2Sus),
1598 46 => Some(Self::Env2Rel),
1599 47 => Some(Self::Env2AtCur),
1600 48 => Some(Self::Env2DcyCur),
1601 49 => Some(Self::Env2SuScur),
1602 50 => Some(Self::Env2RelCur),
1603 51 => Some(Self::Env3Attack),
1604 52 => Some(Self::Env3Decay),
1605 53 => Some(Self::Env3Sus),
1606 54 => Some(Self::Env3Rel),
1607 55 => Some(Self::Env3AtCur),
1608 56 => Some(Self::Env3DcyCur),
1609 57 => Some(Self::Env3SuScur),
1610 58 => Some(Self::Env3RelCur),
1611 59 => Some(Self::VcaAll),
1612 60 => Some(Self::VcaActive),
1613 61 => Some(Self::VcaEnvDep),
1614 62 => Some(Self::PanSpread),
1615 63 => Some(Self::VcaPan),
1616 64 => Some(Self::Osc2Lvl),
1617 65 => Some(Self::NoiseLvl),
1618 66 => Some(Self::HpFreq),
1619 67 => Some(Self::UniDetune),
1620 68 => Some(Self::OscDrift),
1621 69 => Some(Self::ParamDrift),
1622 70 => Some(Self::DriftRate),
1623 71 => Some(Self::ArpGate),
1624 72 => Some(Self::SeqSlew),
1625 73 => Some(Self::Mod1Dep),
1626 74 => Some(Self::Mod2Dep),
1627 75 => Some(Self::Mod3Dep),
1628 76 => Some(Self::Mod4Dep),
1629 77 => Some(Self::Mod5Dep),
1630 78 => Some(Self::Mod6Dep),
1631 79 => Some(Self::Mod7Dep),
1632 80 => Some(Self::Mod8Dep),
1633 81 => Some(Self::Fx1Param1),
1634 82 => Some(Self::Fx1Param2),
1635 83 => Some(Self::Fx1Param3),
1636 84 => Some(Self::Fx1Param4),
1637 85 => Some(Self::Fx1Param5),
1638 86 => Some(Self::Fx1Param6),
1639 87 => Some(Self::Fx1Param7),
1640 88 => Some(Self::Fx1Param8),
1641 89 => Some(Self::Fx1Param9),
1642 90 => Some(Self::Fx1Param10),
1643 91 => Some(Self::Fx1Param11),
1644 92 => Some(Self::Fx1Param12),
1645 93 => Some(Self::Fx2Param1),
1646 94 => Some(Self::Fx2Param2),
1647 95 => Some(Self::Fx2Param3),
1648 96 => Some(Self::Fx2Param4),
1649 97 => Some(Self::Fx2Param5),
1650 98 => Some(Self::Fx2Param6),
1651 99 => Some(Self::Fx2Param7),
1652 100 => Some(Self::Fx2Param8),
1653 101 => Some(Self::Fx2Param9),
1654 102 => Some(Self::Fx2Param10),
1655 103 => Some(Self::Fx2Param11),
1656 104 => Some(Self::Fx2Param12),
1657 105 => Some(Self::Fx3Param1),
1658 106 => Some(Self::Fx3Param2),
1659 107 => Some(Self::Fx3Param3),
1660 108 => Some(Self::Fx3Param4),
1661 109 => Some(Self::Fx3Param5),
1662 110 => Some(Self::Fx3Param6),
1663 111 => Some(Self::Fx3Param7),
1664 112 => Some(Self::Fx3Param8),
1665 113 => Some(Self::Fx3Param9),
1666 114 => Some(Self::Fx3Param10),
1667 115 => Some(Self::Fx3Param11),
1668 116 => Some(Self::Fx3Param12),
1669 117 => Some(Self::Fx4Param1),
1670 118 => Some(Self::Fx4Param2),
1671 119 => Some(Self::Fx4Param3),
1672 120 => Some(Self::Fx4Param4),
1673 121 => Some(Self::Fx4Param5),
1674 122 => Some(Self::Fx4Param6),
1675 123 => Some(Self::Fx4Param7),
1676 124 => Some(Self::Fx4Param8),
1677 125 => Some(Self::Fx4Param9),
1678 126 => Some(Self::Fx4Param10),
1679 127 => Some(Self::Fx4Param11),
1680 128 => Some(Self::Fx4Param12),
1681 129 => Some(Self::Fx1Level),
1682 130 => Some(Self::Fx2Level),
1683 131 => Some(Self::Fx3Level),
1684 132 => Some(Self::Fx4Level),
1685 _ => None,
1686 }
1687 } else {
1688 match raw {
1689 0 => Some(Self::Off),
1690 1 => Some(Self::Lfo1Rate),
1691 2 => Some(Self::Lfo1Delay),
1692 3 => Some(Self::Lfo1Slew),
1693 4 => Some(Self::Lfo1Shape),
1694 5 => Some(Self::Lfo2Rate),
1695 6 => Some(Self::Lfo2Delay),
1696 7 => Some(Self::Lfo2Slew),
1697 8 => Some(Self::Lfo2Shape),
1698 9 => Some(Self::Osc12Pit),
1699 10 => Some(Self::Osc1Pitch),
1700 11 => Some(Self::Osc2Pitch),
1701 12 => Some(Self::Osc1PmDep),
1702 13 => Some(Self::PwmDepth),
1703 14 => Some(Self::TmodDepth),
1704 15 => Some(Self::Osc2PmDep),
1705 16 => Some(Self::PortaTime),
1706 17 => Some(Self::VcfFreq),
1707 18 => Some(Self::VcfRes),
1708 19 => Some(Self::VcfEnv),
1709 20 => Some(Self::VcfLfo),
1710 21 => Some(Self::EnvRates),
1711 22 => Some(Self::AllAttack),
1712 23 => Some(Self::AllDecay),
1713 24 => Some(Self::AllSus),
1714 25 => Some(Self::AllRel),
1715 26 => Some(Self::Env1Rates),
1716 27 => Some(Self::Env2Rates),
1717 28 => Some(Self::Env3Rates),
1718 29 => Some(Self::Env1CurveS),
1719 30 => Some(Self::Env2CurveS),
1720 31 => Some(Self::Env3CurveS),
1721 32 => Some(Self::Env1Attack),
1722 33 => Some(Self::Env1Decay),
1723 34 => Some(Self::Env1Sus),
1724 35 => Some(Self::Env1Rel),
1725 36 => Some(Self::Env1AtCur),
1726 37 => Some(Self::Env1DcyCur),
1727 38 => Some(Self::Env1SuScur),
1728 39 => Some(Self::Env1RelCur),
1729 40 => Some(Self::Env2Attack),
1730 41 => Some(Self::Env2Decay),
1731 42 => Some(Self::Env2Sus),
1732 43 => Some(Self::Env2Rel),
1733 44 => Some(Self::Env2AtCur),
1734 45 => Some(Self::Env2DcyCur),
1735 46 => Some(Self::Env2SuScur),
1736 47 => Some(Self::Env2RelCur),
1737 48 => Some(Self::Env3Attack),
1738 49 => Some(Self::Env3Decay),
1739 50 => Some(Self::Env3Sus),
1740 51 => Some(Self::Env3Rel),
1741 52 => Some(Self::Env3AtCur),
1742 53 => Some(Self::Env3DcyCur),
1743 54 => Some(Self::Env3SuScur),
1744 55 => Some(Self::Env3RelCur),
1745 56 => Some(Self::VcaAll),
1746 57 => Some(Self::VcaActive),
1747 58 => Some(Self::VcaEnvDep),
1748 59 => Some(Self::PanSpread),
1749 60 => Some(Self::VcaPan),
1750 61 => Some(Self::Osc2Lvl),
1751 62 => Some(Self::NoiseLvl),
1752 63 => Some(Self::HpFreq),
1753 64 => Some(Self::UniDetune),
1754 65 => Some(Self::OscDrift),
1755 66 => Some(Self::ParamDrift),
1756 67 => Some(Self::DriftRate),
1757 68 => Some(Self::ArpGate),
1758 69 => Some(Self::SeqSlew),
1759 70 => Some(Self::Mod1Dep),
1760 71 => Some(Self::Mod2Dep),
1761 72 => Some(Self::Mod3Dep),
1762 73 => Some(Self::Mod4Dep),
1763 74 => Some(Self::Mod5Dep),
1764 75 => Some(Self::Mod6Dep),
1765 76 => Some(Self::Mod7Dep),
1766 77 => Some(Self::Mod8Dep),
1767 78 => Some(Self::Fx1Param1),
1768 79 => Some(Self::Fx1Param2),
1769 80 => Some(Self::Fx1Param3),
1770 81 => Some(Self::Fx1Param4),
1771 82 => Some(Self::Fx1Param5),
1772 83 => Some(Self::Fx1Param6),
1773 84 => Some(Self::Fx1Param7),
1774 85 => Some(Self::Fx1Param8),
1775 86 => Some(Self::Fx1Param9),
1776 87 => Some(Self::Fx1Param10),
1777 88 => Some(Self::Fx1Param11),
1778 89 => Some(Self::Fx1Param12),
1779 90 => Some(Self::Fx2Param1),
1780 91 => Some(Self::Fx2Param2),
1781 92 => Some(Self::Fx2Param3),
1782 93 => Some(Self::Fx2Param4),
1783 94 => Some(Self::Fx2Param5),
1784 95 => Some(Self::Fx2Param6),
1785 96 => Some(Self::Fx2Param7),
1786 97 => Some(Self::Fx2Param8),
1787 98 => Some(Self::Fx2Param9),
1788 99 => Some(Self::Fx2Param10),
1789 100 => Some(Self::Fx2Param11),
1790 101 => Some(Self::Fx2Param12),
1791 102 => Some(Self::Fx3Param1),
1792 103 => Some(Self::Fx3Param2),
1793 104 => Some(Self::Fx3Param3),
1794 105 => Some(Self::Fx3Param4),
1795 106 => Some(Self::Fx3Param5),
1796 107 => Some(Self::Fx3Param6),
1797 108 => Some(Self::Fx3Param7),
1798 109 => Some(Self::Fx3Param8),
1799 110 => Some(Self::Fx3Param9),
1800 111 => Some(Self::Fx3Param10),
1801 112 => Some(Self::Fx3Param11),
1802 113 => Some(Self::Fx3Param12),
1803 114 => Some(Self::Fx4Param1),
1804 115 => Some(Self::Fx4Param2),
1805 116 => Some(Self::Fx4Param3),
1806 117 => Some(Self::Fx4Param4),
1807 118 => Some(Self::Fx4Param5),
1808 119 => Some(Self::Fx4Param6),
1809 120 => Some(Self::Fx4Param7),
1810 121 => Some(Self::Fx4Param8),
1811 122 => Some(Self::Fx4Param9),
1812 123 => Some(Self::Fx4Param10),
1813 124 => Some(Self::Fx4Param11),
1814 125 => Some(Self::Fx4Param12),
1815 126 => Some(Self::Fx1Level),
1816 127 => Some(Self::Fx2Level),
1817 128 => Some(Self::Fx3Level),
1818 129 => Some(Self::Fx4Level),
1819 _ => None,
1820 }
1821 }
1822 }
1823
1824 #[must_use]
1826 pub const fn raw(self) -> u8 {
1827 match self {
1828 Self::Off => 0,
1829 Self::Lfo1Rate => 1,
1830 Self::Lfo1Delay => 2,
1831 Self::Lfo1Slew => 3,
1832 Self::Lfo1Shape => 4,
1833 Self::Lfo2Rate => 5,
1834 Self::Lfo2Delay => 6,
1835 Self::Lfo2Slew => 7,
1836 Self::Lfo2Shape => 8,
1837 Self::Osc12Pit => 9,
1838 Self::Osc12Fine => 10,
1839 Self::Osc1Pitch => 11,
1840 Self::Osc1Fine => 12,
1841 Self::Osc2Pitch => 13,
1842 Self::Osc2Fine => 14,
1843 Self::Osc1PmDep => 15,
1844 Self::PwmDepth => 16,
1845 Self::TmodDepth => 17,
1846 Self::Osc2PmDep => 18,
1847 Self::PortaTime => 19,
1848 Self::VcfFreq => 20,
1849 Self::VcfRes => 21,
1850 Self::VcfEnv => 22,
1851 Self::VcfLfo => 23,
1852 Self::EnvRates => 24,
1853 Self::AllAttack => 25,
1854 Self::AllDecay => 26,
1855 Self::AllSus => 27,
1856 Self::AllRel => 28,
1857 Self::Env1Rates => 29,
1858 Self::Env2Rates => 30,
1859 Self::Env3Rates => 31,
1860 Self::Env1CurveS => 32,
1861 Self::Env2CurveS => 33,
1862 Self::Env3CurveS => 34,
1863 Self::Env1Attack => 35,
1864 Self::Env1Decay => 36,
1865 Self::Env1Sus => 37,
1866 Self::Env1Rel => 38,
1867 Self::Env1AtCur => 39,
1868 Self::Env1DcyCur => 40,
1869 Self::Env1SuScur => 41,
1870 Self::Env1RelCur => 42,
1871 Self::Env2Attack => 43,
1872 Self::Env2Decay => 44,
1873 Self::Env2Sus => 45,
1874 Self::Env2Rel => 46,
1875 Self::Env2AtCur => 47,
1876 Self::Env2DcyCur => 48,
1877 Self::Env2SuScur => 49,
1878 Self::Env2RelCur => 50,
1879 Self::Env3Attack => 51,
1880 Self::Env3Decay => 52,
1881 Self::Env3Sus => 53,
1882 Self::Env3Rel => 54,
1883 Self::Env3AtCur => 55,
1884 Self::Env3DcyCur => 56,
1885 Self::Env3SuScur => 57,
1886 Self::Env3RelCur => 58,
1887 Self::VcaAll => 59,
1888 Self::VcaActive => 60,
1889 Self::VcaEnvDep => 61,
1890 Self::PanSpread => 62,
1891 Self::VcaPan => 63,
1892 Self::Osc2Lvl => 64,
1893 Self::NoiseLvl => 65,
1894 Self::HpFreq => 66,
1895 Self::UniDetune => 67,
1896 Self::OscDrift => 68,
1897 Self::ParamDrift => 69,
1898 Self::DriftRate => 70,
1899 Self::ArpGate => 71,
1900 Self::SeqSlew => 72,
1901 Self::Mod1Dep => 73,
1902 Self::Mod2Dep => 74,
1903 Self::Mod3Dep => 75,
1904 Self::Mod4Dep => 76,
1905 Self::Mod5Dep => 77,
1906 Self::Mod6Dep => 78,
1907 Self::Mod7Dep => 79,
1908 Self::Mod8Dep => 80,
1909 Self::Fx1Param1 => 81,
1910 Self::Fx1Param2 => 82,
1911 Self::Fx1Param3 => 83,
1912 Self::Fx1Param4 => 84,
1913 Self::Fx1Param5 => 85,
1914 Self::Fx1Param6 => 86,
1915 Self::Fx1Param7 => 87,
1916 Self::Fx1Param8 => 88,
1917 Self::Fx1Param9 => 89,
1918 Self::Fx1Param10 => 90,
1919 Self::Fx1Param11 => 91,
1920 Self::Fx1Param12 => 92,
1921 Self::Fx2Param1 => 93,
1922 Self::Fx2Param2 => 94,
1923 Self::Fx2Param3 => 95,
1924 Self::Fx2Param4 => 96,
1925 Self::Fx2Param5 => 97,
1926 Self::Fx2Param6 => 98,
1927 Self::Fx2Param7 => 99,
1928 Self::Fx2Param8 => 100,
1929 Self::Fx2Param9 => 101,
1930 Self::Fx2Param10 => 102,
1931 Self::Fx2Param11 => 103,
1932 Self::Fx2Param12 => 104,
1933 Self::Fx3Param1 => 105,
1934 Self::Fx3Param2 => 106,
1935 Self::Fx3Param3 => 107,
1936 Self::Fx3Param4 => 108,
1937 Self::Fx3Param5 => 109,
1938 Self::Fx3Param6 => 110,
1939 Self::Fx3Param7 => 111,
1940 Self::Fx3Param8 => 112,
1941 Self::Fx3Param9 => 113,
1942 Self::Fx3Param10 => 114,
1943 Self::Fx3Param11 => 115,
1944 Self::Fx3Param12 => 116,
1945 Self::Fx4Param1 => 117,
1946 Self::Fx4Param2 => 118,
1947 Self::Fx4Param3 => 119,
1948 Self::Fx4Param4 => 120,
1949 Self::Fx4Param5 => 121,
1950 Self::Fx4Param6 => 122,
1951 Self::Fx4Param7 => 123,
1952 Self::Fx4Param8 => 124,
1953 Self::Fx4Param9 => 125,
1954 Self::Fx4Param10 => 126,
1955 Self::Fx4Param11 => 127,
1956 Self::Fx4Param12 => 128,
1957 Self::Fx1Level => 129,
1958 Self::Fx2Level => 130,
1959 Self::Fx3Level => 131,
1960 Self::Fx4Level => 132,
1961 }
1962 }
1963
1964 #[must_use]
1969 pub const fn raw_for(self, firmware: Version) -> Option<u8> {
1970 if firmware.at_least(1, 1) {
1971 match self {
1972 Self::Off => Some(0),
1973 Self::Lfo1Rate => Some(1),
1974 Self::Lfo1Delay => Some(2),
1975 Self::Lfo1Slew => Some(3),
1976 Self::Lfo1Shape => Some(4),
1977 Self::Lfo2Rate => Some(5),
1978 Self::Lfo2Delay => Some(6),
1979 Self::Lfo2Slew => Some(7),
1980 Self::Lfo2Shape => Some(8),
1981 Self::Osc12Pit => Some(9),
1982 Self::Osc12Fine => Some(10),
1983 Self::Osc1Pitch => Some(11),
1984 Self::Osc1Fine => Some(12),
1985 Self::Osc2Pitch => Some(13),
1986 Self::Osc2Fine => Some(14),
1987 Self::Osc1PmDep => Some(15),
1988 Self::PwmDepth => Some(16),
1989 Self::TmodDepth => Some(17),
1990 Self::Osc2PmDep => Some(18),
1991 Self::PortaTime => Some(19),
1992 Self::VcfFreq => Some(20),
1993 Self::VcfRes => Some(21),
1994 Self::VcfEnv => Some(22),
1995 Self::VcfLfo => Some(23),
1996 Self::EnvRates => Some(24),
1997 Self::AllAttack => Some(25),
1998 Self::AllDecay => Some(26),
1999 Self::AllSus => Some(27),
2000 Self::AllRel => Some(28),
2001 Self::Env1Rates => Some(29),
2002 Self::Env2Rates => Some(30),
2003 Self::Env3Rates => Some(31),
2004 Self::Env1CurveS => Some(32),
2005 Self::Env2CurveS => Some(33),
2006 Self::Env3CurveS => Some(34),
2007 Self::Env1Attack => Some(35),
2008 Self::Env1Decay => Some(36),
2009 Self::Env1Sus => Some(37),
2010 Self::Env1Rel => Some(38),
2011 Self::Env1AtCur => Some(39),
2012 Self::Env1DcyCur => Some(40),
2013 Self::Env1SuScur => Some(41),
2014 Self::Env1RelCur => Some(42),
2015 Self::Env2Attack => Some(43),
2016 Self::Env2Decay => Some(44),
2017 Self::Env2Sus => Some(45),
2018 Self::Env2Rel => Some(46),
2019 Self::Env2AtCur => Some(47),
2020 Self::Env2DcyCur => Some(48),
2021 Self::Env2SuScur => Some(49),
2022 Self::Env2RelCur => Some(50),
2023 Self::Env3Attack => Some(51),
2024 Self::Env3Decay => Some(52),
2025 Self::Env3Sus => Some(53),
2026 Self::Env3Rel => Some(54),
2027 Self::Env3AtCur => Some(55),
2028 Self::Env3DcyCur => Some(56),
2029 Self::Env3SuScur => Some(57),
2030 Self::Env3RelCur => Some(58),
2031 Self::VcaAll => Some(59),
2032 Self::VcaActive => Some(60),
2033 Self::VcaEnvDep => Some(61),
2034 Self::PanSpread => Some(62),
2035 Self::VcaPan => Some(63),
2036 Self::Osc2Lvl => Some(64),
2037 Self::NoiseLvl => Some(65),
2038 Self::HpFreq => Some(66),
2039 Self::UniDetune => Some(67),
2040 Self::OscDrift => Some(68),
2041 Self::ParamDrift => Some(69),
2042 Self::DriftRate => Some(70),
2043 Self::ArpGate => Some(71),
2044 Self::SeqSlew => Some(72),
2045 Self::Mod1Dep => Some(73),
2046 Self::Mod2Dep => Some(74),
2047 Self::Mod3Dep => Some(75),
2048 Self::Mod4Dep => Some(76),
2049 Self::Mod5Dep => Some(77),
2050 Self::Mod6Dep => Some(78),
2051 Self::Mod7Dep => Some(79),
2052 Self::Mod8Dep => Some(80),
2053 Self::Fx1Param1 => Some(81),
2054 Self::Fx1Param2 => Some(82),
2055 Self::Fx1Param3 => Some(83),
2056 Self::Fx1Param4 => Some(84),
2057 Self::Fx1Param5 => Some(85),
2058 Self::Fx1Param6 => Some(86),
2059 Self::Fx1Param7 => Some(87),
2060 Self::Fx1Param8 => Some(88),
2061 Self::Fx1Param9 => Some(89),
2062 Self::Fx1Param10 => Some(90),
2063 Self::Fx1Param11 => Some(91),
2064 Self::Fx1Param12 => Some(92),
2065 Self::Fx2Param1 => Some(93),
2066 Self::Fx2Param2 => Some(94),
2067 Self::Fx2Param3 => Some(95),
2068 Self::Fx2Param4 => Some(96),
2069 Self::Fx2Param5 => Some(97),
2070 Self::Fx2Param6 => Some(98),
2071 Self::Fx2Param7 => Some(99),
2072 Self::Fx2Param8 => Some(100),
2073 Self::Fx2Param9 => Some(101),
2074 Self::Fx2Param10 => Some(102),
2075 Self::Fx2Param11 => Some(103),
2076 Self::Fx2Param12 => Some(104),
2077 Self::Fx3Param1 => Some(105),
2078 Self::Fx3Param2 => Some(106),
2079 Self::Fx3Param3 => Some(107),
2080 Self::Fx3Param4 => Some(108),
2081 Self::Fx3Param5 => Some(109),
2082 Self::Fx3Param6 => Some(110),
2083 Self::Fx3Param7 => Some(111),
2084 Self::Fx3Param8 => Some(112),
2085 Self::Fx3Param9 => Some(113),
2086 Self::Fx3Param10 => Some(114),
2087 Self::Fx3Param11 => Some(115),
2088 Self::Fx3Param12 => Some(116),
2089 Self::Fx4Param1 => Some(117),
2090 Self::Fx4Param2 => Some(118),
2091 Self::Fx4Param3 => Some(119),
2092 Self::Fx4Param4 => Some(120),
2093 Self::Fx4Param5 => Some(121),
2094 Self::Fx4Param6 => Some(122),
2095 Self::Fx4Param7 => Some(123),
2096 Self::Fx4Param8 => Some(124),
2097 Self::Fx4Param9 => Some(125),
2098 Self::Fx4Param10 => Some(126),
2099 Self::Fx4Param11 => Some(127),
2100 Self::Fx4Param12 => Some(128),
2101 Self::Fx1Level => Some(129),
2102 Self::Fx2Level => Some(130),
2103 Self::Fx3Level => Some(131),
2104 Self::Fx4Level => Some(132),
2105 }
2106 } else {
2107 match self {
2108 Self::Off => Some(0),
2109 Self::Lfo1Rate => Some(1),
2110 Self::Lfo1Delay => Some(2),
2111 Self::Lfo1Slew => Some(3),
2112 Self::Lfo1Shape => Some(4),
2113 Self::Lfo2Rate => Some(5),
2114 Self::Lfo2Delay => Some(6),
2115 Self::Lfo2Slew => Some(7),
2116 Self::Lfo2Shape => Some(8),
2117 Self::Osc12Pit => Some(9),
2118 Self::Osc12Fine => None,
2119 Self::Osc1Pitch => Some(10),
2120 Self::Osc1Fine => None,
2121 Self::Osc2Pitch => Some(11),
2122 Self::Osc2Fine => None,
2123 Self::Osc1PmDep => Some(12),
2124 Self::PwmDepth => Some(13),
2125 Self::TmodDepth => Some(14),
2126 Self::Osc2PmDep => Some(15),
2127 Self::PortaTime => Some(16),
2128 Self::VcfFreq => Some(17),
2129 Self::VcfRes => Some(18),
2130 Self::VcfEnv => Some(19),
2131 Self::VcfLfo => Some(20),
2132 Self::EnvRates => Some(21),
2133 Self::AllAttack => Some(22),
2134 Self::AllDecay => Some(23),
2135 Self::AllSus => Some(24),
2136 Self::AllRel => Some(25),
2137 Self::Env1Rates => Some(26),
2138 Self::Env2Rates => Some(27),
2139 Self::Env3Rates => Some(28),
2140 Self::Env1CurveS => Some(29),
2141 Self::Env2CurveS => Some(30),
2142 Self::Env3CurveS => Some(31),
2143 Self::Env1Attack => Some(32),
2144 Self::Env1Decay => Some(33),
2145 Self::Env1Sus => Some(34),
2146 Self::Env1Rel => Some(35),
2147 Self::Env1AtCur => Some(36),
2148 Self::Env1DcyCur => Some(37),
2149 Self::Env1SuScur => Some(38),
2150 Self::Env1RelCur => Some(39),
2151 Self::Env2Attack => Some(40),
2152 Self::Env2Decay => Some(41),
2153 Self::Env2Sus => Some(42),
2154 Self::Env2Rel => Some(43),
2155 Self::Env2AtCur => Some(44),
2156 Self::Env2DcyCur => Some(45),
2157 Self::Env2SuScur => Some(46),
2158 Self::Env2RelCur => Some(47),
2159 Self::Env3Attack => Some(48),
2160 Self::Env3Decay => Some(49),
2161 Self::Env3Sus => Some(50),
2162 Self::Env3Rel => Some(51),
2163 Self::Env3AtCur => Some(52),
2164 Self::Env3DcyCur => Some(53),
2165 Self::Env3SuScur => Some(54),
2166 Self::Env3RelCur => Some(55),
2167 Self::VcaAll => Some(56),
2168 Self::VcaActive => Some(57),
2169 Self::VcaEnvDep => Some(58),
2170 Self::PanSpread => Some(59),
2171 Self::VcaPan => Some(60),
2172 Self::Osc2Lvl => Some(61),
2173 Self::NoiseLvl => Some(62),
2174 Self::HpFreq => Some(63),
2175 Self::UniDetune => Some(64),
2176 Self::OscDrift => Some(65),
2177 Self::ParamDrift => Some(66),
2178 Self::DriftRate => Some(67),
2179 Self::ArpGate => Some(68),
2180 Self::SeqSlew => Some(69),
2181 Self::Mod1Dep => Some(70),
2182 Self::Mod2Dep => Some(71),
2183 Self::Mod3Dep => Some(72),
2184 Self::Mod4Dep => Some(73),
2185 Self::Mod5Dep => Some(74),
2186 Self::Mod6Dep => Some(75),
2187 Self::Mod7Dep => Some(76),
2188 Self::Mod8Dep => Some(77),
2189 Self::Fx1Param1 => Some(78),
2190 Self::Fx1Param2 => Some(79),
2191 Self::Fx1Param3 => Some(80),
2192 Self::Fx1Param4 => Some(81),
2193 Self::Fx1Param5 => Some(82),
2194 Self::Fx1Param6 => Some(83),
2195 Self::Fx1Param7 => Some(84),
2196 Self::Fx1Param8 => Some(85),
2197 Self::Fx1Param9 => Some(86),
2198 Self::Fx1Param10 => Some(87),
2199 Self::Fx1Param11 => Some(88),
2200 Self::Fx1Param12 => Some(89),
2201 Self::Fx2Param1 => Some(90),
2202 Self::Fx2Param2 => Some(91),
2203 Self::Fx2Param3 => Some(92),
2204 Self::Fx2Param4 => Some(93),
2205 Self::Fx2Param5 => Some(94),
2206 Self::Fx2Param6 => Some(95),
2207 Self::Fx2Param7 => Some(96),
2208 Self::Fx2Param8 => Some(97),
2209 Self::Fx2Param9 => Some(98),
2210 Self::Fx2Param10 => Some(99),
2211 Self::Fx2Param11 => Some(100),
2212 Self::Fx2Param12 => Some(101),
2213 Self::Fx3Param1 => Some(102),
2214 Self::Fx3Param2 => Some(103),
2215 Self::Fx3Param3 => Some(104),
2216 Self::Fx3Param4 => Some(105),
2217 Self::Fx3Param5 => Some(106),
2218 Self::Fx3Param6 => Some(107),
2219 Self::Fx3Param7 => Some(108),
2220 Self::Fx3Param8 => Some(109),
2221 Self::Fx3Param9 => Some(110),
2222 Self::Fx3Param10 => Some(111),
2223 Self::Fx3Param11 => Some(112),
2224 Self::Fx3Param12 => Some(113),
2225 Self::Fx4Param1 => Some(114),
2226 Self::Fx4Param2 => Some(115),
2227 Self::Fx4Param3 => Some(116),
2228 Self::Fx4Param4 => Some(117),
2229 Self::Fx4Param5 => Some(118),
2230 Self::Fx4Param6 => Some(119),
2231 Self::Fx4Param7 => Some(120),
2232 Self::Fx4Param8 => Some(121),
2233 Self::Fx4Param9 => Some(122),
2234 Self::Fx4Param10 => Some(123),
2235 Self::Fx4Param11 => Some(124),
2236 Self::Fx4Param12 => Some(125),
2237 Self::Fx1Level => Some(126),
2238 Self::Fx2Level => Some(127),
2239 Self::Fx3Level => Some(128),
2240 Self::Fx4Level => Some(129),
2241 }
2242 }
2243 }
2244
2245 #[must_use]
2248 pub fn name(self) -> &'static str {
2249 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
2250 }
2251
2252 #[must_use]
2259 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
2260 let raw = self.raw_for(firmware)?;
2261 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
2262 }
2263}
2264
2265impl fmt::Display for ModDestination {
2266 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2267 f.write_str(self.name())
2268 }
2269}
2270
2271#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2281#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2282#[non_exhaustive]
2283pub enum ModSource {
2284 Off,
2286 PitchBend,
2288 ModWheel,
2290 FootCtrl,
2292 BreathCtrl,
2294 Pressure,
2296 Expression,
2298 Lfo1,
2300 Lfo2,
2302 Env1,
2304 Env2,
2306 Env3,
2308 NoteNum,
2310 NoteVel,
2312 NoteOffVel,
2314 CtrlSeq,
2316 Lfo1Uni,
2318 Lfo2Uni,
2320 Lfo1Fade,
2322 Lfo2Fade,
2324 VoiceNum,
2326 UniVoice,
2328 CcX,
2330 CcY,
2332 CcZ,
2334}
2335
2336impl ModSource {
2337 pub const TABLE: TableId = TableId::ModSource;
2339
2340 pub const ALL: &'static [Self] = &[
2342 Self::Off,
2343 Self::PitchBend,
2344 Self::ModWheel,
2345 Self::FootCtrl,
2346 Self::BreathCtrl,
2347 Self::Pressure,
2348 Self::Expression,
2349 Self::Lfo1,
2350 Self::Lfo2,
2351 Self::Env1,
2352 Self::Env2,
2353 Self::Env3,
2354 Self::NoteNum,
2355 Self::NoteVel,
2356 Self::NoteOffVel,
2357 Self::CtrlSeq,
2358 Self::Lfo1Uni,
2359 Self::Lfo2Uni,
2360 Self::Lfo1Fade,
2361 Self::Lfo2Fade,
2362 Self::VoiceNum,
2363 Self::UniVoice,
2364 Self::CcX,
2365 Self::CcY,
2366 Self::CcZ,
2367 ];
2368
2369 #[must_use]
2373 pub const fn from_raw(raw: u8) -> Option<Self> {
2374 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
2375 }
2376
2377 #[must_use]
2383 pub const fn from_raw_for(raw: u8, firmware: Version) -> Option<Self> {
2384 if firmware.at_least(1, 1) {
2385 match raw {
2386 0 => Some(Self::Off),
2387 1 => Some(Self::PitchBend),
2388 2 => Some(Self::ModWheel),
2389 3 => Some(Self::FootCtrl),
2390 4 => Some(Self::BreathCtrl),
2391 5 => Some(Self::Pressure),
2392 6 => Some(Self::Expression),
2393 7 => Some(Self::Lfo1),
2394 8 => Some(Self::Lfo2),
2395 9 => Some(Self::Env1),
2396 10 => Some(Self::Env2),
2397 11 => Some(Self::Env3),
2398 12 => Some(Self::NoteNum),
2399 13 => Some(Self::NoteVel),
2400 14 => Some(Self::NoteOffVel),
2401 15 => Some(Self::CtrlSeq),
2402 16 => Some(Self::Lfo1Uni),
2403 17 => Some(Self::Lfo2Uni),
2404 18 => Some(Self::Lfo1Fade),
2405 19 => Some(Self::Lfo2Fade),
2406 20 => Some(Self::VoiceNum),
2407 21 => Some(Self::UniVoice),
2408 22 => Some(Self::CcX),
2409 23 => Some(Self::CcY),
2410 24 => Some(Self::CcZ),
2411 _ => None,
2412 }
2413 } else {
2414 match raw {
2415 0 => Some(Self::Off),
2416 1 => Some(Self::PitchBend),
2417 2 => Some(Self::ModWheel),
2418 3 => Some(Self::FootCtrl),
2419 4 => Some(Self::BreathCtrl),
2420 5 => Some(Self::Pressure),
2421 6 => Some(Self::Lfo1),
2422 7 => Some(Self::Lfo2),
2423 8 => Some(Self::Env1),
2424 9 => Some(Self::Env2),
2425 10 => Some(Self::Env3),
2426 11 => Some(Self::NoteNum),
2427 12 => Some(Self::NoteVel),
2428 13 => Some(Self::CtrlSeq),
2429 14 => Some(Self::Lfo1Uni),
2430 15 => Some(Self::Lfo2Uni),
2431 16 => Some(Self::Lfo1Fade),
2432 17 => Some(Self::Lfo2Fade),
2433 18 => Some(Self::NoteOffVel),
2434 19 => Some(Self::VoiceNum),
2435 20 => Some(Self::CcX),
2436 21 => Some(Self::CcY),
2437 22 => Some(Self::CcZ),
2438 _ => None,
2439 }
2440 }
2441 }
2442
2443 #[must_use]
2445 pub const fn raw(self) -> u8 {
2446 match self {
2447 Self::Off => 0,
2448 Self::PitchBend => 1,
2449 Self::ModWheel => 2,
2450 Self::FootCtrl => 3,
2451 Self::BreathCtrl => 4,
2452 Self::Pressure => 5,
2453 Self::Expression => 6,
2454 Self::Lfo1 => 7,
2455 Self::Lfo2 => 8,
2456 Self::Env1 => 9,
2457 Self::Env2 => 10,
2458 Self::Env3 => 11,
2459 Self::NoteNum => 12,
2460 Self::NoteVel => 13,
2461 Self::NoteOffVel => 14,
2462 Self::CtrlSeq => 15,
2463 Self::Lfo1Uni => 16,
2464 Self::Lfo2Uni => 17,
2465 Self::Lfo1Fade => 18,
2466 Self::Lfo2Fade => 19,
2467 Self::VoiceNum => 20,
2468 Self::UniVoice => 21,
2469 Self::CcX => 22,
2470 Self::CcY => 23,
2471 Self::CcZ => 24,
2472 }
2473 }
2474
2475 #[must_use]
2480 pub const fn raw_for(self, firmware: Version) -> Option<u8> {
2481 if firmware.at_least(1, 1) {
2482 match self {
2483 Self::Off => Some(0),
2484 Self::PitchBend => Some(1),
2485 Self::ModWheel => Some(2),
2486 Self::FootCtrl => Some(3),
2487 Self::BreathCtrl => Some(4),
2488 Self::Pressure => Some(5),
2489 Self::Expression => Some(6),
2490 Self::Lfo1 => Some(7),
2491 Self::Lfo2 => Some(8),
2492 Self::Env1 => Some(9),
2493 Self::Env2 => Some(10),
2494 Self::Env3 => Some(11),
2495 Self::NoteNum => Some(12),
2496 Self::NoteVel => Some(13),
2497 Self::NoteOffVel => Some(14),
2498 Self::CtrlSeq => Some(15),
2499 Self::Lfo1Uni => Some(16),
2500 Self::Lfo2Uni => Some(17),
2501 Self::Lfo1Fade => Some(18),
2502 Self::Lfo2Fade => Some(19),
2503 Self::VoiceNum => Some(20),
2504 Self::UniVoice => Some(21),
2505 Self::CcX => Some(22),
2506 Self::CcY => Some(23),
2507 Self::CcZ => Some(24),
2508 }
2509 } else {
2510 match self {
2511 Self::Off => Some(0),
2512 Self::PitchBend => Some(1),
2513 Self::ModWheel => Some(2),
2514 Self::FootCtrl => Some(3),
2515 Self::BreathCtrl => Some(4),
2516 Self::Pressure => Some(5),
2517 Self::Expression => None,
2518 Self::Lfo1 => Some(6),
2519 Self::Lfo2 => Some(7),
2520 Self::Env1 => Some(8),
2521 Self::Env2 => Some(9),
2522 Self::Env3 => Some(10),
2523 Self::NoteNum => Some(11),
2524 Self::NoteVel => Some(12),
2525 Self::NoteOffVel => Some(18),
2526 Self::CtrlSeq => Some(13),
2527 Self::Lfo1Uni => Some(14),
2528 Self::Lfo2Uni => Some(15),
2529 Self::Lfo1Fade => Some(16),
2530 Self::Lfo2Fade => Some(17),
2531 Self::VoiceNum => Some(19),
2532 Self::UniVoice => None,
2533 Self::CcX => Some(20),
2534 Self::CcY => Some(21),
2535 Self::CcZ => Some(22),
2536 }
2537 }
2538 }
2539
2540 #[must_use]
2543 pub fn name(self) -> &'static str {
2544 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
2545 }
2546
2547 #[must_use]
2554 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
2555 let raw = self.raw_for(firmware)?;
2556 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
2557 }
2558}
2559
2560impl fmt::Display for ModSource {
2561 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2562 f.write_str(self.name())
2563 }
2564}
2565
2566#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2572#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2573#[non_exhaustive]
2574pub enum Osc1PitchModMode {
2575 Osc12,
2577 Osc1Only,
2579}
2580
2581impl Osc1PitchModMode {
2582 pub const TABLE: TableId = TableId::Osc1PitchModMode;
2584
2585 pub const ALL: &'static [Self] = &[Self::Osc12, Self::Osc1Only];
2587
2588 #[must_use]
2592 pub const fn from_raw(raw: u8) -> Option<Self> {
2593 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
2594 }
2595
2596 #[must_use]
2602 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
2603 match raw {
2604 0 => Some(Self::Osc12),
2605 1 => Some(Self::Osc1Only),
2606 _ => None,
2607 }
2608 }
2609
2610 #[must_use]
2612 pub const fn raw(self) -> u8 {
2613 match self {
2614 Self::Osc12 => 0,
2615 Self::Osc1Only => 1,
2616 }
2617 }
2618
2619 #[must_use]
2624 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
2625 Some(self.raw())
2626 }
2627
2628 #[must_use]
2631 pub fn name(self) -> &'static str {
2632 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
2633 }
2634
2635 #[must_use]
2642 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
2643 let raw = self.raw_for(firmware)?;
2644 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
2645 }
2646}
2647
2648impl fmt::Display for Osc1PitchModMode {
2649 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2650 f.write_str(self.name())
2651 }
2652}
2653
2654#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2660#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2661#[non_exhaustive]
2662pub enum OscRange {
2663 SixteenFoot,
2665 EightFoot,
2667 FourFoot,
2669}
2670
2671impl OscRange {
2672 pub const TABLE: TableId = TableId::OscRange;
2674
2675 pub const ALL: &'static [Self] = &[Self::SixteenFoot, Self::EightFoot, Self::FourFoot];
2677
2678 #[must_use]
2682 pub const fn from_raw(raw: u8) -> Option<Self> {
2683 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
2684 }
2685
2686 #[must_use]
2692 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
2693 match raw {
2694 0 => Some(Self::SixteenFoot),
2695 1 => Some(Self::EightFoot),
2696 2 => Some(Self::FourFoot),
2697 _ => None,
2698 }
2699 }
2700
2701 #[must_use]
2703 pub const fn raw(self) -> u8 {
2704 match self {
2705 Self::SixteenFoot => 0,
2706 Self::EightFoot => 1,
2707 Self::FourFoot => 2,
2708 }
2709 }
2710
2711 #[must_use]
2716 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
2717 Some(self.raw())
2718 }
2719
2720 #[must_use]
2723 pub fn name(self) -> &'static str {
2724 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
2725 }
2726
2727 #[must_use]
2734 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
2735 let raw = self.raw_for(firmware)?;
2736 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
2737 }
2738}
2739
2740impl fmt::Display for OscRange {
2741 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2742 f.write_str(self.name())
2743 }
2744}
2745
2746#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2752#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2753#[non_exhaustive]
2754pub enum PitchModSource {
2755 Lfo1,
2757 Lfo2,
2759 VcaEnv,
2761 VcfEnv,
2763 ModEnv,
2765 Lfo1Unipolar,
2767 Lfo2Unipolar,
2769}
2770
2771impl PitchModSource {
2772 pub const TABLE: TableId = TableId::PitchModSource;
2774
2775 pub const ALL: &'static [Self] = &[
2777 Self::Lfo1,
2778 Self::Lfo2,
2779 Self::VcaEnv,
2780 Self::VcfEnv,
2781 Self::ModEnv,
2782 Self::Lfo1Unipolar,
2783 Self::Lfo2Unipolar,
2784 ];
2785
2786 #[must_use]
2790 pub const fn from_raw(raw: u8) -> Option<Self> {
2791 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
2792 }
2793
2794 #[must_use]
2800 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
2801 match raw {
2802 0 => Some(Self::Lfo1),
2803 1 => Some(Self::Lfo2),
2804 2 => Some(Self::VcaEnv),
2805 3 => Some(Self::VcfEnv),
2806 4 => Some(Self::ModEnv),
2807 5 => Some(Self::Lfo1Unipolar),
2808 6 => Some(Self::Lfo2Unipolar),
2809 _ => None,
2810 }
2811 }
2812
2813 #[must_use]
2815 pub const fn raw(self) -> u8 {
2816 match self {
2817 Self::Lfo1 => 0,
2818 Self::Lfo2 => 1,
2819 Self::VcaEnv => 2,
2820 Self::VcfEnv => 3,
2821 Self::ModEnv => 4,
2822 Self::Lfo1Unipolar => 5,
2823 Self::Lfo2Unipolar => 6,
2824 }
2825 }
2826
2827 #[must_use]
2832 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
2833 Some(self.raw())
2834 }
2835
2836 #[must_use]
2839 pub fn name(self) -> &'static str {
2840 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
2841 }
2842
2843 #[must_use]
2850 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
2851 let raw = self.raw_for(firmware)?;
2852 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
2853 }
2854}
2855
2856impl fmt::Display for PitchModSource {
2857 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2858 f.write_str(self.name())
2859 }
2860}
2861
2862#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2868#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2869#[non_exhaustive]
2870pub enum PolyphonyMode {
2871 Poly,
2873 Unison2,
2875 Unison3,
2877 Unison4,
2879 Unison6,
2881 Unison12,
2883 Mono,
2885 Mono2,
2887 Mono3,
2889 Mono4,
2891 Mono6,
2893 Poly6,
2895 Poly8,
2897}
2898
2899impl PolyphonyMode {
2900 pub const TABLE: TableId = TableId::PolyphonyMode;
2902
2903 pub const ALL: &'static [Self] = &[
2905 Self::Poly,
2906 Self::Unison2,
2907 Self::Unison3,
2908 Self::Unison4,
2909 Self::Unison6,
2910 Self::Unison12,
2911 Self::Mono,
2912 Self::Mono2,
2913 Self::Mono3,
2914 Self::Mono4,
2915 Self::Mono6,
2916 Self::Poly6,
2917 Self::Poly8,
2918 ];
2919
2920 #[must_use]
2924 pub const fn from_raw(raw: u8) -> Option<Self> {
2925 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
2926 }
2927
2928 #[must_use]
2934 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
2935 match raw {
2936 0 => Some(Self::Poly),
2937 1 => Some(Self::Unison2),
2938 2 => Some(Self::Unison3),
2939 3 => Some(Self::Unison4),
2940 4 => Some(Self::Unison6),
2941 5 => Some(Self::Unison12),
2942 6 => Some(Self::Mono),
2943 7 => Some(Self::Mono2),
2944 8 => Some(Self::Mono3),
2945 9 => Some(Self::Mono4),
2946 10 => Some(Self::Mono6),
2947 11 => Some(Self::Poly6),
2948 12 => Some(Self::Poly8),
2949 _ => None,
2950 }
2951 }
2952
2953 #[must_use]
2955 pub const fn raw(self) -> u8 {
2956 match self {
2957 Self::Poly => 0,
2958 Self::Unison2 => 1,
2959 Self::Unison3 => 2,
2960 Self::Unison4 => 3,
2961 Self::Unison6 => 4,
2962 Self::Unison12 => 5,
2963 Self::Mono => 6,
2964 Self::Mono2 => 7,
2965 Self::Mono3 => 8,
2966 Self::Mono4 => 9,
2967 Self::Mono6 => 10,
2968 Self::Poly6 => 11,
2969 Self::Poly8 => 12,
2970 }
2971 }
2972
2973 #[must_use]
2978 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
2979 Some(self.raw())
2980 }
2981
2982 #[must_use]
2985 pub fn name(self) -> &'static str {
2986 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
2987 }
2988
2989 #[must_use]
2996 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
2997 let raw = self.raw_for(firmware)?;
2998 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
2999 }
3000}
3001
3002impl fmt::Display for PolyphonyMode {
3003 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3004 f.write_str(self.name())
3005 }
3006}
3007
3008#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3014#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3015#[non_exhaustive]
3016pub enum PortamentoMode {
3017 Normal,
3019 Fingered,
3021 FixedRate,
3023 FixedRateFingered,
3025 Exponential,
3027 ExponentialFingered,
3029 FixedPlus2,
3031 FixedMinus2,
3033 FixedPlus5,
3035 FixedMinus5,
3037 FixedPlus12,
3039 FixedMinus12,
3041 FixedPlus24,
3043 FixedMinus24,
3045}
3046
3047impl PortamentoMode {
3048 pub const TABLE: TableId = TableId::PortamentoMode;
3050
3051 pub const ALL: &'static [Self] = &[
3053 Self::Normal,
3054 Self::Fingered,
3055 Self::FixedRate,
3056 Self::FixedRateFingered,
3057 Self::Exponential,
3058 Self::ExponentialFingered,
3059 Self::FixedPlus2,
3060 Self::FixedMinus2,
3061 Self::FixedPlus5,
3062 Self::FixedMinus5,
3063 Self::FixedPlus12,
3064 Self::FixedMinus12,
3065 Self::FixedPlus24,
3066 Self::FixedMinus24,
3067 ];
3068
3069 #[must_use]
3073 pub const fn from_raw(raw: u8) -> Option<Self> {
3074 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3075 }
3076
3077 #[must_use]
3083 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3084 match raw {
3085 0 => Some(Self::Normal),
3086 1 => Some(Self::Fingered),
3087 2 => Some(Self::FixedRate),
3088 3 => Some(Self::FixedRateFingered),
3089 4 => Some(Self::Exponential),
3090 5 => Some(Self::ExponentialFingered),
3091 6 => Some(Self::FixedPlus2),
3092 7 => Some(Self::FixedMinus2),
3093 8 => Some(Self::FixedPlus5),
3094 9 => Some(Self::FixedMinus5),
3095 10 => Some(Self::FixedPlus12),
3096 11 => Some(Self::FixedMinus12),
3097 12 => Some(Self::FixedPlus24),
3098 13 => Some(Self::FixedMinus24),
3099 _ => None,
3100 }
3101 }
3102
3103 #[must_use]
3105 pub const fn raw(self) -> u8 {
3106 match self {
3107 Self::Normal => 0,
3108 Self::Fingered => 1,
3109 Self::FixedRate => 2,
3110 Self::FixedRateFingered => 3,
3111 Self::Exponential => 4,
3112 Self::ExponentialFingered => 5,
3113 Self::FixedPlus2 => 6,
3114 Self::FixedMinus2 => 7,
3115 Self::FixedPlus5 => 8,
3116 Self::FixedMinus5 => 9,
3117 Self::FixedPlus12 => 10,
3118 Self::FixedMinus12 => 11,
3119 Self::FixedPlus24 => 12,
3120 Self::FixedMinus24 => 13,
3121 }
3122 }
3123
3124 #[must_use]
3129 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3130 Some(self.raw())
3131 }
3132
3133 #[must_use]
3136 pub fn name(self) -> &'static str {
3137 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3138 }
3139
3140 #[must_use]
3147 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3148 let raw = self.raw_for(firmware)?;
3149 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3150 }
3151}
3152
3153impl fmt::Display for PortamentoMode {
3154 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3155 f.write_str(self.name())
3156 }
3157}
3158
3159#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3165#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3166#[non_exhaustive]
3167pub enum ProgramCategory {
3168 None,
3170 Bass,
3172 Pad,
3174 Lead,
3176 Mono,
3178 Poly,
3180 Stab,
3182 Sfx,
3184 Arp,
3186 Seq,
3188 Perc,
3190 Ambient,
3192 Modular,
3194 User1,
3196 User2,
3198 User3,
3200 User4,
3202}
3203
3204impl ProgramCategory {
3205 pub const TABLE: TableId = TableId::ProgramCategory;
3207
3208 pub const ALL: &'static [Self] = &[
3210 Self::None,
3211 Self::Bass,
3212 Self::Pad,
3213 Self::Lead,
3214 Self::Mono,
3215 Self::Poly,
3216 Self::Stab,
3217 Self::Sfx,
3218 Self::Arp,
3219 Self::Seq,
3220 Self::Perc,
3221 Self::Ambient,
3222 Self::Modular,
3223 Self::User1,
3224 Self::User2,
3225 Self::User3,
3226 Self::User4,
3227 ];
3228
3229 #[must_use]
3233 pub const fn from_raw(raw: u8) -> Option<Self> {
3234 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3235 }
3236
3237 #[must_use]
3243 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3244 match raw {
3245 0 => Some(Self::None),
3246 1 => Some(Self::Bass),
3247 2 => Some(Self::Pad),
3248 3 => Some(Self::Lead),
3249 4 => Some(Self::Mono),
3250 5 => Some(Self::Poly),
3251 6 => Some(Self::Stab),
3252 7 => Some(Self::Sfx),
3253 8 => Some(Self::Arp),
3254 9 => Some(Self::Seq),
3255 10 => Some(Self::Perc),
3256 11 => Some(Self::Ambient),
3257 12 => Some(Self::Modular),
3258 13 => Some(Self::User1),
3259 14 => Some(Self::User2),
3260 15 => Some(Self::User3),
3261 16 => Some(Self::User4),
3262 _ => None,
3263 }
3264 }
3265
3266 #[must_use]
3268 pub const fn raw(self) -> u8 {
3269 match self {
3270 Self::None => 0,
3271 Self::Bass => 1,
3272 Self::Pad => 2,
3273 Self::Lead => 3,
3274 Self::Mono => 4,
3275 Self::Poly => 5,
3276 Self::Stab => 6,
3277 Self::Sfx => 7,
3278 Self::Arp => 8,
3279 Self::Seq => 9,
3280 Self::Perc => 10,
3281 Self::Ambient => 11,
3282 Self::Modular => 12,
3283 Self::User1 => 13,
3284 Self::User2 => 14,
3285 Self::User3 => 15,
3286 Self::User4 => 16,
3287 }
3288 }
3289
3290 #[must_use]
3295 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3296 Some(self.raw())
3297 }
3298
3299 #[must_use]
3302 pub fn name(self) -> &'static str {
3303 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3304 }
3305
3306 #[must_use]
3313 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3314 let raw = self.raw_for(firmware)?;
3315 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3316 }
3317}
3318
3319impl fmt::Display for ProgramCategory {
3320 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3321 f.write_str(self.name())
3322 }
3323}
3324
3325#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3331#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3332#[non_exhaustive]
3333pub enum PwmSource {
3334 Manual,
3336 Lfo1,
3338 Lfo2,
3340 VcaEnv,
3342 VcfEnv,
3344 ModEnv,
3346}
3347
3348impl PwmSource {
3349 pub const TABLE: TableId = TableId::PwmSource;
3351
3352 pub const ALL: &'static [Self] = &[
3354 Self::Manual,
3355 Self::Lfo1,
3356 Self::Lfo2,
3357 Self::VcaEnv,
3358 Self::VcfEnv,
3359 Self::ModEnv,
3360 ];
3361
3362 #[must_use]
3366 pub const fn from_raw(raw: u8) -> Option<Self> {
3367 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3368 }
3369
3370 #[must_use]
3376 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3377 match raw {
3378 0 => Some(Self::Manual),
3379 1 => Some(Self::Lfo1),
3380 2 => Some(Self::Lfo2),
3381 3 => Some(Self::VcaEnv),
3382 4 => Some(Self::VcfEnv),
3383 5 => Some(Self::ModEnv),
3384 _ => None,
3385 }
3386 }
3387
3388 #[must_use]
3390 pub const fn raw(self) -> u8 {
3391 match self {
3392 Self::Manual => 0,
3393 Self::Lfo1 => 1,
3394 Self::Lfo2 => 2,
3395 Self::VcaEnv => 3,
3396 Self::VcfEnv => 4,
3397 Self::ModEnv => 5,
3398 }
3399 }
3400
3401 #[must_use]
3406 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3407 Some(self.raw())
3408 }
3409
3410 #[must_use]
3413 pub fn name(self) -> &'static str {
3414 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3415 }
3416
3417 #[must_use]
3424 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3425 let raw = self.raw_for(firmware)?;
3426 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3427 }
3428}
3429
3430impl fmt::Display for PwmSource {
3431 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3432 f.write_str(self.name())
3433 }
3434}
3435
3436#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3442#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3443#[non_exhaustive]
3444pub enum SequencerSync {
3445 LoopOn,
3447 KeySyncOn,
3449 LoopAndKeySyncOn,
3451}
3452
3453impl SequencerSync {
3454 pub const TABLE: TableId = TableId::SequencerSync;
3456
3457 pub const ALL: &'static [Self] = &[Self::LoopOn, Self::KeySyncOn, Self::LoopAndKeySyncOn];
3459
3460 #[must_use]
3464 pub const fn from_raw(raw: u8) -> Option<Self> {
3465 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3466 }
3467
3468 #[must_use]
3474 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3475 match raw {
3476 0 => Some(Self::LoopOn),
3477 1 => Some(Self::KeySyncOn),
3478 2 => Some(Self::LoopAndKeySyncOn),
3479 _ => None,
3480 }
3481 }
3482
3483 #[must_use]
3485 pub const fn raw(self) -> u8 {
3486 match self {
3487 Self::LoopOn => 0,
3488 Self::KeySyncOn => 1,
3489 Self::LoopAndKeySyncOn => 2,
3490 }
3491 }
3492
3493 #[must_use]
3498 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3499 Some(self.raw())
3500 }
3501
3502 #[must_use]
3505 pub fn name(self) -> &'static str {
3506 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3507 }
3508
3509 #[must_use]
3516 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3517 let raw = self.raw_for(firmware)?;
3518 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3519 }
3520}
3521
3522impl fmt::Display for SequencerSync {
3523 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3524 f.write_str(self.name())
3525 }
3526}
3527
3528#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3534#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3535#[non_exhaustive]
3536pub enum ToneModSource {
3537 Manual,
3539 Lfo1,
3541 Lfo2,
3543 VcaEnv,
3545 VcfEnv,
3547 ModEnv,
3549}
3550
3551impl ToneModSource {
3552 pub const TABLE: TableId = TableId::ToneModSource;
3554
3555 pub const ALL: &'static [Self] = &[
3557 Self::Manual,
3558 Self::Lfo1,
3559 Self::Lfo2,
3560 Self::VcaEnv,
3561 Self::VcfEnv,
3562 Self::ModEnv,
3563 ];
3564
3565 #[must_use]
3569 pub const fn from_raw(raw: u8) -> Option<Self> {
3570 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3571 }
3572
3573 #[must_use]
3579 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3580 match raw {
3581 0 => Some(Self::Manual),
3582 1 => Some(Self::Lfo1),
3583 2 => Some(Self::Lfo2),
3584 3 => Some(Self::VcaEnv),
3585 4 => Some(Self::VcfEnv),
3586 5 => Some(Self::ModEnv),
3587 _ => None,
3588 }
3589 }
3590
3591 #[must_use]
3593 pub const fn raw(self) -> u8 {
3594 match self {
3595 Self::Manual => 0,
3596 Self::Lfo1 => 1,
3597 Self::Lfo2 => 2,
3598 Self::VcaEnv => 3,
3599 Self::VcfEnv => 4,
3600 Self::ModEnv => 5,
3601 }
3602 }
3603
3604 #[must_use]
3609 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3610 Some(self.raw())
3611 }
3612
3613 #[must_use]
3616 pub fn name(self) -> &'static str {
3617 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3618 }
3619
3620 #[must_use]
3627 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3628 let raw = self.raw_for(firmware)?;
3629 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3630 }
3631}
3632
3633impl fmt::Display for ToneModSource {
3634 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3635 f.write_str(self.name())
3636 }
3637}
3638
3639#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3645#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3646#[non_exhaustive]
3647pub enum VcfEnvelopePolarity {
3648 Negative,
3650 Positive,
3652}
3653
3654impl VcfEnvelopePolarity {
3655 pub const TABLE: TableId = TableId::VcfEnvelopePolarity;
3657
3658 pub const ALL: &'static [Self] = &[Self::Negative, Self::Positive];
3660
3661 #[must_use]
3665 pub const fn from_raw(raw: u8) -> Option<Self> {
3666 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3667 }
3668
3669 #[must_use]
3675 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3676 match raw {
3677 0 => Some(Self::Negative),
3678 1 => Some(Self::Positive),
3679 _ => None,
3680 }
3681 }
3682
3683 #[must_use]
3685 pub const fn raw(self) -> u8 {
3686 match self {
3687 Self::Negative => 0,
3688 Self::Positive => 1,
3689 }
3690 }
3691
3692 #[must_use]
3697 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3698 Some(self.raw())
3699 }
3700
3701 #[must_use]
3704 pub fn name(self) -> &'static str {
3705 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3706 }
3707
3708 #[must_use]
3715 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3716 let raw = self.raw_for(firmware)?;
3717 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3718 }
3719}
3720
3721impl fmt::Display for VcfEnvelopePolarity {
3722 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3723 f.write_str(self.name())
3724 }
3725}
3726
3727#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3733#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3734#[non_exhaustive]
3735pub enum VcfLfoSelect {
3736 Lfo1,
3738 Lfo2,
3740}
3741
3742impl VcfLfoSelect {
3743 pub const TABLE: TableId = TableId::VcfLfoSelect;
3745
3746 pub const ALL: &'static [Self] = &[Self::Lfo1, Self::Lfo2];
3748
3749 #[must_use]
3753 pub const fn from_raw(raw: u8) -> Option<Self> {
3754 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3755 }
3756
3757 #[must_use]
3763 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3764 match raw {
3765 0 => Some(Self::Lfo1),
3766 1 => Some(Self::Lfo2),
3767 _ => None,
3768 }
3769 }
3770
3771 #[must_use]
3773 pub const fn raw(self) -> u8 {
3774 match self {
3775 Self::Lfo1 => 0,
3776 Self::Lfo2 => 1,
3777 }
3778 }
3779
3780 #[must_use]
3785 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3786 Some(self.raw())
3787 }
3788
3789 #[must_use]
3792 pub fn name(self) -> &'static str {
3793 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3794 }
3795
3796 #[must_use]
3803 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3804 let raw = self.raw_for(firmware)?;
3805 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3806 }
3807}
3808
3809impl fmt::Display for VcfLfoSelect {
3810 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3811 f.write_str(self.name())
3812 }
3813}
3814
3815#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3821#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3822#[non_exhaustive]
3823pub enum VcfPoleMode {
3824 FourPole,
3826 TwoPole,
3828}
3829
3830impl VcfPoleMode {
3831 pub const TABLE: TableId = TableId::VcfPoleMode;
3833
3834 pub const ALL: &'static [Self] = &[Self::FourPole, Self::TwoPole];
3836
3837 #[must_use]
3841 pub const fn from_raw(raw: u8) -> Option<Self> {
3842 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3843 }
3844
3845 #[must_use]
3851 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3852 match raw {
3853 0 => Some(Self::FourPole),
3854 1 => Some(Self::TwoPole),
3855 _ => None,
3856 }
3857 }
3858
3859 #[must_use]
3861 pub const fn raw(self) -> u8 {
3862 match self {
3863 Self::FourPole => 0,
3864 Self::TwoPole => 1,
3865 }
3866 }
3867
3868 #[must_use]
3873 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3874 Some(self.raw())
3875 }
3876
3877 #[must_use]
3880 pub fn name(self) -> &'static str {
3881 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3882 }
3883
3884 #[must_use]
3891 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3892 let raw = self.raw_for(firmware)?;
3893 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3894 }
3895}
3896
3897impl fmt::Display for VcfPoleMode {
3898 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3899 f.write_str(self.name())
3900 }
3901}
3902
3903#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3909#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3910#[non_exhaustive]
3911pub enum VoicePriority {
3912 Lowest,
3914 Highest,
3916 Last,
3918}
3919
3920impl VoicePriority {
3921 pub const TABLE: TableId = TableId::VoicePriority;
3923
3924 pub const ALL: &'static [Self] = &[Self::Lowest, Self::Highest, Self::Last];
3926
3927 #[must_use]
3931 pub const fn from_raw(raw: u8) -> Option<Self> {
3932 Self::from_raw_for(raw, DEFAULT_FIRMWARE)
3933 }
3934
3935 #[must_use]
3941 pub const fn from_raw_for(raw: u8, _firmware: Version) -> Option<Self> {
3942 match raw {
3943 0 => Some(Self::Lowest),
3944 1 => Some(Self::Highest),
3945 2 => Some(Self::Last),
3946 _ => None,
3947 }
3948 }
3949
3950 #[must_use]
3952 pub const fn raw(self) -> u8 {
3953 match self {
3954 Self::Lowest => 0,
3955 Self::Highest => 1,
3956 Self::Last => 2,
3957 }
3958 }
3959
3960 #[must_use]
3965 pub const fn raw_for(self, _firmware: Version) -> Option<u8> {
3966 Some(self.raw())
3967 }
3968
3969 #[must_use]
3972 pub fn name(self) -> &'static str {
3973 self.name_for(DEFAULT_FIRMWARE).unwrap_or_default()
3974 }
3975
3976 #[must_use]
3983 pub fn name_for(self, firmware: Version) -> Option<&'static str> {
3984 let raw = self.raw_for(firmware)?;
3985 Self::TABLE.table_for(firmware).name_of(u16::from(raw))
3986 }
3987}
3988
3989impl fmt::Display for VoicePriority {
3990 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3991 f.write_str(self.name())
3992 }
3993}
3994
3995impl Program {
4004 #[must_use]
4008 pub fn lfo1_rate(&self) -> u8 {
4009 self.get(ParamId::Lfo1Rate)
4010 }
4011
4012 pub fn set_lfo1_rate(&mut self, value: u8) {
4014 self.set_clamped(ParamId::Lfo1Rate, value);
4015 }
4016
4017 #[must_use]
4021 pub fn lfo1_delay_fade(&self) -> u8 {
4022 self.get(ParamId::Lfo1DelayFade)
4023 }
4024
4025 pub fn set_lfo1_delay_fade(&mut self, value: u8) {
4027 self.set_clamped(ParamId::Lfo1DelayFade, value);
4028 }
4029
4030 #[must_use]
4036 pub fn lfo1_shape(&self) -> Option<LfoShape> {
4037 LfoShape::from_raw(self.get(ParamId::Lfo1Shape))
4038 }
4039
4040 pub fn set_lfo1_shape(&mut self, value: LfoShape) {
4042 self.set_clamped(ParamId::Lfo1Shape, value.raw());
4043 }
4044
4045 #[must_use]
4049 pub fn lfo1_key_sync(&self) -> bool {
4050 self.get(ParamId::Lfo1KeySync) != 0
4051 }
4052
4053 pub fn set_lfo1_key_sync(&mut self, value: bool) {
4055 self.set_clamped(ParamId::Lfo1KeySync, u8::from(value));
4056 }
4057
4058 #[must_use]
4062 pub fn lfo1_arp_sync(&self) -> bool {
4063 self.get(ParamId::Lfo1ArpSync) != 0
4064 }
4065
4066 pub fn set_lfo1_arp_sync(&mut self, value: bool) {
4068 self.set_clamped(ParamId::Lfo1ArpSync, u8::from(value));
4069 }
4070
4071 #[must_use]
4075 pub fn lfo1_mono_mode(&self) -> u8 {
4076 self.get(ParamId::Lfo1MonoMode)
4077 }
4078
4079 pub fn set_lfo1_mono_mode(&mut self, value: u8) {
4081 self.set_clamped(ParamId::Lfo1MonoMode, value);
4082 }
4083
4084 #[must_use]
4088 pub fn lfo1_slew_rate(&self) -> u8 {
4089 self.get(ParamId::Lfo1SlewRate)
4090 }
4091
4092 pub fn set_lfo1_slew_rate(&mut self, value: u8) {
4094 self.set_clamped(ParamId::Lfo1SlewRate, value);
4095 }
4096
4097 #[must_use]
4101 pub fn lfo2_rate(&self) -> u8 {
4102 self.get(ParamId::Lfo2Rate)
4103 }
4104
4105 pub fn set_lfo2_rate(&mut self, value: u8) {
4107 self.set_clamped(ParamId::Lfo2Rate, value);
4108 }
4109
4110 #[must_use]
4114 pub fn lfo2_delay_fade(&self) -> u8 {
4115 self.get(ParamId::Lfo2DelayFade)
4116 }
4117
4118 pub fn set_lfo2_delay_fade(&mut self, value: u8) {
4120 self.set_clamped(ParamId::Lfo2DelayFade, value);
4121 }
4122
4123 #[must_use]
4129 pub fn lfo2_shape(&self) -> Option<LfoShape> {
4130 LfoShape::from_raw(self.get(ParamId::Lfo2Shape))
4131 }
4132
4133 pub fn set_lfo2_shape(&mut self, value: LfoShape) {
4135 self.set_clamped(ParamId::Lfo2Shape, value.raw());
4136 }
4137
4138 #[must_use]
4142 pub fn lfo2_key_sync(&self) -> bool {
4143 self.get(ParamId::Lfo2KeySync) != 0
4144 }
4145
4146 pub fn set_lfo2_key_sync(&mut self, value: bool) {
4148 self.set_clamped(ParamId::Lfo2KeySync, u8::from(value));
4149 }
4150
4151 #[must_use]
4155 pub fn lfo2_arp_sync(&self) -> bool {
4156 self.get(ParamId::Lfo2ArpSync) != 0
4157 }
4158
4159 pub fn set_lfo2_arp_sync(&mut self, value: bool) {
4161 self.set_clamped(ParamId::Lfo2ArpSync, u8::from(value));
4162 }
4163
4164 #[must_use]
4168 pub fn lfo2_mono_mode(&self) -> u8 {
4169 self.get(ParamId::Lfo2MonoMode)
4170 }
4171
4172 pub fn set_lfo2_mono_mode(&mut self, value: u8) {
4174 self.set_clamped(ParamId::Lfo2MonoMode, value);
4175 }
4176
4177 #[must_use]
4181 pub fn lfo2_slew_rate(&self) -> u8 {
4182 self.get(ParamId::Lfo2SlewRate)
4183 }
4184
4185 pub fn set_lfo2_slew_rate(&mut self, value: u8) {
4187 self.set_clamped(ParamId::Lfo2SlewRate, value);
4188 }
4189
4190 #[must_use]
4196 pub fn osc1_range(&self) -> Option<OscRange> {
4197 OscRange::from_raw(self.get(ParamId::Osc1Range))
4198 }
4199
4200 pub fn set_osc1_range(&mut self, value: OscRange) {
4202 self.set_clamped(ParamId::Osc1Range, value.raw());
4203 }
4204
4205 #[must_use]
4211 pub fn osc2_range(&self) -> Option<OscRange> {
4212 OscRange::from_raw(self.get(ParamId::Osc2Range))
4213 }
4214
4215 pub fn set_osc2_range(&mut self, value: OscRange) {
4217 self.set_clamped(ParamId::Osc2Range, value.raw());
4218 }
4219
4220 #[must_use]
4226 pub fn osc1_pwm_source(&self) -> Option<PwmSource> {
4227 PwmSource::from_raw(self.get(ParamId::Osc1PwmSource))
4228 }
4229
4230 pub fn set_osc1_pwm_source(&mut self, value: PwmSource) {
4232 self.set_clamped(ParamId::Osc1PwmSource, value.raw());
4233 }
4234
4235 #[must_use]
4241 pub fn osc2_tone_mod_source(&self) -> Option<ToneModSource> {
4242 ToneModSource::from_raw(self.get(ParamId::Osc2ToneModSource))
4243 }
4244
4245 pub fn set_osc2_tone_mod_source(&mut self, value: ToneModSource) {
4247 self.set_clamped(ParamId::Osc2ToneModSource, value.raw());
4248 }
4249
4250 #[must_use]
4254 pub fn osc1_pulse_enable(&self) -> bool {
4255 self.get(ParamId::Osc1PulseEnable) != 0
4256 }
4257
4258 pub fn set_osc1_pulse_enable(&mut self, value: bool) {
4260 self.set_clamped(ParamId::Osc1PulseEnable, u8::from(value));
4261 }
4262
4263 #[must_use]
4267 pub fn osc1_saw_enable(&self) -> bool {
4268 self.get(ParamId::Osc1SawEnable) != 0
4269 }
4270
4271 pub fn set_osc1_saw_enable(&mut self, value: bool) {
4273 self.set_clamped(ParamId::Osc1SawEnable, u8::from(value));
4274 }
4275
4276 #[must_use]
4280 pub fn osc_sync_enable(&self) -> bool {
4281 self.get(ParamId::OscSyncEnable) != 0
4282 }
4283
4284 pub fn set_osc_sync_enable(&mut self, value: bool) {
4286 self.set_clamped(ParamId::OscSyncEnable, u8::from(value));
4287 }
4288
4289 #[must_use]
4293 pub fn osc1_pitch_mod_depth(&self) -> u8 {
4294 self.get(ParamId::Osc1PitchModDepth)
4295 }
4296
4297 pub fn set_osc1_pitch_mod_depth(&mut self, value: u8) {
4299 self.set_clamped(ParamId::Osc1PitchModDepth, value);
4300 }
4301
4302 #[must_use]
4308 pub fn osc1_pitch_mod_select(&self) -> Option<PitchModSource> {
4309 PitchModSource::from_raw(self.get(ParamId::Osc1PitchModSelect))
4310 }
4311
4312 pub fn set_osc1_pitch_mod_select(&mut self, value: PitchModSource) {
4314 self.set_clamped(ParamId::Osc1PitchModSelect, value.raw());
4315 }
4316
4317 #[must_use]
4321 pub fn osc1_aftertouch_to_pitch_mod_depth(&self) -> u8 {
4322 self.get(ParamId::Osc1AftertouchToPitchModDepth)
4323 }
4324
4325 pub fn set_osc1_aftertouch_to_pitch_mod_depth(&mut self, value: u8) {
4327 self.set_clamped(ParamId::Osc1AftertouchToPitchModDepth, value);
4328 }
4329
4330 #[must_use]
4334 pub fn osc1_mod_wheel_to_pitch_mod_depth(&self) -> u8 {
4335 self.get(ParamId::Osc1ModWheelToPitchModDepth)
4336 }
4337
4338 pub fn set_osc1_mod_wheel_to_pitch_mod_depth(&mut self, value: u8) {
4340 self.set_clamped(ParamId::Osc1ModWheelToPitchModDepth, value);
4341 }
4342
4343 #[must_use]
4347 pub fn osc1_pwm_depth(&self) -> u8 {
4348 self.get(ParamId::Osc1PwmDepth)
4349 }
4350
4351 pub fn set_osc1_pwm_depth(&mut self, value: u8) {
4353 self.set_clamped(ParamId::Osc1PwmDepth, value);
4354 }
4355
4356 #[must_use]
4360 pub fn osc2_level(&self) -> u8 {
4361 self.get(ParamId::Osc2Level)
4362 }
4363
4364 pub fn set_osc2_level(&mut self, value: u8) {
4366 self.set_clamped(ParamId::Osc2Level, value);
4367 }
4368
4369 #[must_use]
4373 pub fn osc2_pitch(&self) -> u8 {
4374 self.get(ParamId::Osc2Pitch)
4375 }
4376
4377 pub fn set_osc2_pitch(&mut self, value: u8) {
4379 self.set_clamped(ParamId::Osc2Pitch, value);
4380 }
4381
4382 #[must_use]
4386 pub fn osc2_tone_mod_depth(&self) -> u8 {
4387 self.get(ParamId::Osc2ToneModDepth)
4388 }
4389
4390 pub fn set_osc2_tone_mod_depth(&mut self, value: u8) {
4392 self.set_clamped(ParamId::Osc2ToneModDepth, value);
4393 }
4394
4395 #[must_use]
4399 pub fn osc2_pitch_mod_depth(&self) -> u8 {
4400 self.get(ParamId::Osc2PitchModDepth)
4401 }
4402
4403 pub fn set_osc2_pitch_mod_depth(&mut self, value: u8) {
4405 self.set_clamped(ParamId::Osc2PitchModDepth, value);
4406 }
4407
4408 #[must_use]
4412 pub fn osc2_aftertouch_to_pitch_mod_depth(&self) -> u8 {
4413 self.get(ParamId::Osc2AftertouchToPitchModDepth)
4414 }
4415
4416 pub fn set_osc2_aftertouch_to_pitch_mod_depth(&mut self, value: u8) {
4418 self.set_clamped(ParamId::Osc2AftertouchToPitchModDepth, value);
4419 }
4420
4421 #[must_use]
4425 pub fn osc2_mod_wheel_to_pitch_mod_depth(&self) -> u8 {
4426 self.get(ParamId::Osc2ModWheelToPitchModDepth)
4427 }
4428
4429 pub fn set_osc2_mod_wheel_to_pitch_mod_depth(&mut self, value: u8) {
4431 self.set_clamped(ParamId::Osc2ModWheelToPitchModDepth, value);
4432 }
4433
4434 #[must_use]
4440 pub fn osc2_pitch_mod_select(&self) -> Option<PitchModSource> {
4441 PitchModSource::from_raw(self.get(ParamId::Osc2PitchModSelect))
4442 }
4443
4444 pub fn set_osc2_pitch_mod_select(&mut self, value: PitchModSource) {
4446 self.set_clamped(ParamId::Osc2PitchModSelect, value.raw());
4447 }
4448
4449 #[must_use]
4453 pub fn noise_level(&self) -> u8 {
4454 self.get(ParamId::NoiseLevel)
4455 }
4456
4457 pub fn set_noise_level(&mut self, value: u8) {
4459 self.set_clamped(ParamId::NoiseLevel, value);
4460 }
4461
4462 #[must_use]
4466 pub fn portamento_time(&self) -> u8 {
4467 self.get(ParamId::PortamentoTime)
4468 }
4469
4470 pub fn set_portamento_time(&mut self, value: u8) {
4472 self.set_clamped(ParamId::PortamentoTime, value);
4473 }
4474
4475 #[must_use]
4481 pub fn portamento_mode(&self) -> Option<PortamentoMode> {
4482 PortamentoMode::from_raw(self.get(ParamId::PortamentoMode))
4483 }
4484
4485 pub fn set_portamento_mode(&mut self, value: PortamentoMode) {
4487 self.set_clamped(ParamId::PortamentoMode, value.raw());
4488 }
4489
4490 #[must_use]
4494 pub fn pitch_bend_up_depth(&self) -> u8 {
4495 self.get(ParamId::PitchBendUpDepth)
4496 }
4497
4498 pub fn set_pitch_bend_up_depth(&mut self, value: u8) {
4500 self.set_clamped(ParamId::PitchBendUpDepth, value);
4501 }
4502
4503 #[must_use]
4507 pub fn pitch_bend_down_depth(&self) -> u8 {
4508 self.get(ParamId::PitchBendDownDepth)
4509 }
4510
4511 pub fn set_pitch_bend_down_depth(&mut self, value: u8) {
4513 self.set_clamped(ParamId::PitchBendDownDepth, value);
4514 }
4515
4516 #[must_use]
4522 pub fn osc1_pitch_mod_mode(&self) -> Option<Osc1PitchModMode> {
4523 Osc1PitchModMode::from_raw(self.get(ParamId::Osc1PitchModMode))
4524 }
4525
4526 pub fn set_osc1_pitch_mod_mode(&mut self, value: Osc1PitchModMode) {
4528 self.set_clamped(ParamId::Osc1PitchModMode, value.raw());
4529 }
4530
4531 #[must_use]
4535 pub fn vcf_frequency(&self) -> u8 {
4536 self.get(ParamId::VcfFrequency)
4537 }
4538
4539 pub fn set_vcf_frequency(&mut self, value: u8) {
4541 self.set_clamped(ParamId::VcfFrequency, value);
4542 }
4543
4544 #[must_use]
4548 pub fn vcf_high_pass_frequency(&self) -> u8 {
4549 self.get(ParamId::VcfHighPassFrequency)
4550 }
4551
4552 pub fn set_vcf_high_pass_frequency(&mut self, value: u8) {
4554 self.set_clamped(ParamId::VcfHighPassFrequency, value);
4555 }
4556
4557 #[must_use]
4561 pub fn vcf_resonance(&self) -> u8 {
4562 self.get(ParamId::VcfResonance)
4563 }
4564
4565 pub fn set_vcf_resonance(&mut self, value: u8) {
4567 self.set_clamped(ParamId::VcfResonance, value);
4568 }
4569
4570 #[must_use]
4574 pub fn vcf_envelope_depth(&self) -> u8 {
4575 self.get(ParamId::VcfEnvelopeDepth)
4576 }
4577
4578 pub fn set_vcf_envelope_depth(&mut self, value: u8) {
4580 self.set_clamped(ParamId::VcfEnvelopeDepth, value);
4581 }
4582
4583 #[must_use]
4587 pub fn vcf_envelope_velocity_sensitivity(&self) -> u8 {
4588 self.get(ParamId::VcfEnvelopeVelocitySensitivity)
4589 }
4590
4591 pub fn set_vcf_envelope_velocity_sensitivity(&mut self, value: u8) {
4593 self.set_clamped(ParamId::VcfEnvelopeVelocitySensitivity, value);
4594 }
4595
4596 #[must_use]
4600 pub fn vcf_pitch_bend_to_freq_depth(&self) -> u8 {
4601 self.get(ParamId::VcfPitchBendToFreqDepth)
4602 }
4603
4604 pub fn set_vcf_pitch_bend_to_freq_depth(&mut self, value: u8) {
4606 self.set_clamped(ParamId::VcfPitchBendToFreqDepth, value);
4607 }
4608
4609 #[must_use]
4613 pub fn vcf_lfo_depth(&self) -> u8 {
4614 self.get(ParamId::VcfLfoDepth)
4615 }
4616
4617 pub fn set_vcf_lfo_depth(&mut self, value: u8) {
4619 self.set_clamped(ParamId::VcfLfoDepth, value);
4620 }
4621
4622 #[must_use]
4628 pub fn vcf_lfo_select(&self) -> Option<VcfLfoSelect> {
4629 VcfLfoSelect::from_raw(self.get(ParamId::VcfLfoSelect))
4630 }
4631
4632 pub fn set_vcf_lfo_select(&mut self, value: VcfLfoSelect) {
4634 self.set_clamped(ParamId::VcfLfoSelect, value.raw());
4635 }
4636
4637 #[must_use]
4641 pub fn vcf_aftertouch_to_lfo_depth(&self) -> u8 {
4642 self.get(ParamId::VcfAftertouchToLfoDepth)
4643 }
4644
4645 pub fn set_vcf_aftertouch_to_lfo_depth(&mut self, value: u8) {
4647 self.set_clamped(ParamId::VcfAftertouchToLfoDepth, value);
4648 }
4649
4650 #[must_use]
4654 pub fn vcf_mod_wheel_to_lfo_depth(&self) -> u8 {
4655 self.get(ParamId::VcfModWheelToLfoDepth)
4656 }
4657
4658 pub fn set_vcf_mod_wheel_to_lfo_depth(&mut self, value: u8) {
4660 self.set_clamped(ParamId::VcfModWheelToLfoDepth, value);
4661 }
4662
4663 #[must_use]
4667 pub fn vcf_keyboard_tracking(&self) -> u8 {
4668 self.get(ParamId::VcfKeyboardTracking)
4669 }
4670
4671 pub fn set_vcf_keyboard_tracking(&mut self, value: u8) {
4673 self.set_clamped(ParamId::VcfKeyboardTracking, value);
4674 }
4675
4676 #[must_use]
4682 pub fn vcf_envelope_polarity(&self) -> Option<VcfEnvelopePolarity> {
4683 VcfEnvelopePolarity::from_raw(self.get(ParamId::VcfEnvelopePolarity))
4684 }
4685
4686 pub fn set_vcf_envelope_polarity(&mut self, value: VcfEnvelopePolarity) {
4688 self.set_clamped(ParamId::VcfEnvelopePolarity, value.raw());
4689 }
4690
4691 #[must_use]
4697 pub fn vcf2_pole_mode(&self) -> Option<VcfPoleMode> {
4698 VcfPoleMode::from_raw(self.get(ParamId::Vcf2PoleMode))
4699 }
4700
4701 pub fn set_vcf2_pole_mode(&mut self, value: VcfPoleMode) {
4703 self.set_clamped(ParamId::Vcf2PoleMode, value.raw());
4704 }
4705
4706 #[must_use]
4710 pub fn vcf_bass_boost(&self) -> bool {
4711 self.get(ParamId::VcfBassBoost) != 0
4712 }
4713
4714 pub fn set_vcf_bass_boost(&mut self, value: bool) {
4716 self.set_clamped(ParamId::VcfBassBoost, u8::from(value));
4717 }
4718
4719 #[must_use]
4723 pub fn vca_envelope_attack_time(&self) -> u8 {
4724 self.get(ParamId::VcaEnvelopeAttackTime)
4725 }
4726
4727 pub fn set_vca_envelope_attack_time(&mut self, value: u8) {
4729 self.set_clamped(ParamId::VcaEnvelopeAttackTime, value);
4730 }
4731
4732 #[must_use]
4736 pub fn vca_envelope_decay_time(&self) -> u8 {
4737 self.get(ParamId::VcaEnvelopeDecayTime)
4738 }
4739
4740 pub fn set_vca_envelope_decay_time(&mut self, value: u8) {
4742 self.set_clamped(ParamId::VcaEnvelopeDecayTime, value);
4743 }
4744
4745 #[must_use]
4749 pub fn vca_envelope_sustain_level(&self) -> u8 {
4750 self.get(ParamId::VcaEnvelopeSustainLevel)
4751 }
4752
4753 pub fn set_vca_envelope_sustain_level(&mut self, value: u8) {
4755 self.set_clamped(ParamId::VcaEnvelopeSustainLevel, value);
4756 }
4757
4758 #[must_use]
4762 pub fn vca_envelope_release_time(&self) -> u8 {
4763 self.get(ParamId::VcaEnvelopeReleaseTime)
4764 }
4765
4766 pub fn set_vca_envelope_release_time(&mut self, value: u8) {
4768 self.set_clamped(ParamId::VcaEnvelopeReleaseTime, value);
4769 }
4770
4771 #[must_use]
4777 pub fn vca_envelope_trigger_mode(&self) -> Option<EnvelopeTrigger> {
4778 EnvelopeTrigger::from_raw(self.get(ParamId::VcaEnvelopeTriggerMode))
4779 }
4780
4781 pub fn set_vca_envelope_trigger_mode(&mut self, value: EnvelopeTrigger) {
4783 self.set_clamped(ParamId::VcaEnvelopeTriggerMode, value.raw());
4784 }
4785
4786 #[must_use]
4790 pub fn vca_envelope_attack_curve(&self) -> u8 {
4791 self.get(ParamId::VcaEnvelopeAttackCurve)
4792 }
4793
4794 pub fn set_vca_envelope_attack_curve(&mut self, value: u8) {
4796 self.set_clamped(ParamId::VcaEnvelopeAttackCurve, value);
4797 }
4798
4799 #[must_use]
4803 pub fn vca_envelope_decay_curve(&self) -> u8 {
4804 self.get(ParamId::VcaEnvelopeDecayCurve)
4805 }
4806
4807 pub fn set_vca_envelope_decay_curve(&mut self, value: u8) {
4809 self.set_clamped(ParamId::VcaEnvelopeDecayCurve, value);
4810 }
4811
4812 #[must_use]
4816 pub fn vca_envelope_sustain_curve(&self) -> u8 {
4817 self.get(ParamId::VcaEnvelopeSustainCurve)
4818 }
4819
4820 pub fn set_vca_envelope_sustain_curve(&mut self, value: u8) {
4822 self.set_clamped(ParamId::VcaEnvelopeSustainCurve, value);
4823 }
4824
4825 #[must_use]
4829 pub fn vca_envelope_release_curve(&self) -> u8 {
4830 self.get(ParamId::VcaEnvelopeReleaseCurve)
4831 }
4832
4833 pub fn set_vca_envelope_release_curve(&mut self, value: u8) {
4835 self.set_clamped(ParamId::VcaEnvelopeReleaseCurve, value);
4836 }
4837
4838 #[must_use]
4842 pub fn vcf_envelope_attack_time(&self) -> u8 {
4843 self.get(ParamId::VcfEnvelopeAttackTime)
4844 }
4845
4846 pub fn set_vcf_envelope_attack_time(&mut self, value: u8) {
4848 self.set_clamped(ParamId::VcfEnvelopeAttackTime, value);
4849 }
4850
4851 #[must_use]
4855 pub fn vcf_envelope_decay_time(&self) -> u8 {
4856 self.get(ParamId::VcfEnvelopeDecayTime)
4857 }
4858
4859 pub fn set_vcf_envelope_decay_time(&mut self, value: u8) {
4861 self.set_clamped(ParamId::VcfEnvelopeDecayTime, value);
4862 }
4863
4864 #[must_use]
4868 pub fn vcf_envelope_sustain_level(&self) -> u8 {
4869 self.get(ParamId::VcfEnvelopeSustainLevel)
4870 }
4871
4872 pub fn set_vcf_envelope_sustain_level(&mut self, value: u8) {
4874 self.set_clamped(ParamId::VcfEnvelopeSustainLevel, value);
4875 }
4876
4877 #[must_use]
4881 pub fn vcf_envelope_release_time(&self) -> u8 {
4882 self.get(ParamId::VcfEnvelopeReleaseTime)
4883 }
4884
4885 pub fn set_vcf_envelope_release_time(&mut self, value: u8) {
4887 self.set_clamped(ParamId::VcfEnvelopeReleaseTime, value);
4888 }
4889
4890 #[must_use]
4896 pub fn vcf_envelope_trigger_mode(&self) -> Option<EnvelopeTrigger> {
4897 EnvelopeTrigger::from_raw(self.get(ParamId::VcfEnvelopeTriggerMode))
4898 }
4899
4900 pub fn set_vcf_envelope_trigger_mode(&mut self, value: EnvelopeTrigger) {
4902 self.set_clamped(ParamId::VcfEnvelopeTriggerMode, value.raw());
4903 }
4904
4905 #[must_use]
4909 pub fn vcf_envelope_attack_curve(&self) -> u8 {
4910 self.get(ParamId::VcfEnvelopeAttackCurve)
4911 }
4912
4913 pub fn set_vcf_envelope_attack_curve(&mut self, value: u8) {
4915 self.set_clamped(ParamId::VcfEnvelopeAttackCurve, value);
4916 }
4917
4918 #[must_use]
4922 pub fn vcf_envelope_decay_curve(&self) -> u8 {
4923 self.get(ParamId::VcfEnvelopeDecayCurve)
4924 }
4925
4926 pub fn set_vcf_envelope_decay_curve(&mut self, value: u8) {
4928 self.set_clamped(ParamId::VcfEnvelopeDecayCurve, value);
4929 }
4930
4931 #[must_use]
4935 pub fn vcf_envelope_sustain_curve(&self) -> u8 {
4936 self.get(ParamId::VcfEnvelopeSustainCurve)
4937 }
4938
4939 pub fn set_vcf_envelope_sustain_curve(&mut self, value: u8) {
4941 self.set_clamped(ParamId::VcfEnvelopeSustainCurve, value);
4942 }
4943
4944 #[must_use]
4948 pub fn vcf_envelope_release_curve(&self) -> u8 {
4949 self.get(ParamId::VcfEnvelopeReleaseCurve)
4950 }
4951
4952 pub fn set_vcf_envelope_release_curve(&mut self, value: u8) {
4954 self.set_clamped(ParamId::VcfEnvelopeReleaseCurve, value);
4955 }
4956
4957 #[must_use]
4961 pub fn mod_envelope_attack_time(&self) -> u8 {
4962 self.get(ParamId::ModEnvelopeAttackTime)
4963 }
4964
4965 pub fn set_mod_envelope_attack_time(&mut self, value: u8) {
4967 self.set_clamped(ParamId::ModEnvelopeAttackTime, value);
4968 }
4969
4970 #[must_use]
4974 pub fn mod_envelope_decay_time(&self) -> u8 {
4975 self.get(ParamId::ModEnvelopeDecayTime)
4976 }
4977
4978 pub fn set_mod_envelope_decay_time(&mut self, value: u8) {
4980 self.set_clamped(ParamId::ModEnvelopeDecayTime, value);
4981 }
4982
4983 #[must_use]
4987 pub fn mod_envelope_sustain_level(&self) -> u8 {
4988 self.get(ParamId::ModEnvelopeSustainLevel)
4989 }
4990
4991 pub fn set_mod_envelope_sustain_level(&mut self, value: u8) {
4993 self.set_clamped(ParamId::ModEnvelopeSustainLevel, value);
4994 }
4995
4996 #[must_use]
5000 pub fn mod_envelope_release_time(&self) -> u8 {
5001 self.get(ParamId::ModEnvelopeReleaseTime)
5002 }
5003
5004 pub fn set_mod_envelope_release_time(&mut self, value: u8) {
5006 self.set_clamped(ParamId::ModEnvelopeReleaseTime, value);
5007 }
5008
5009 #[must_use]
5015 pub fn mod_envelope_trigger_mode(&self) -> Option<EnvelopeTrigger> {
5016 EnvelopeTrigger::from_raw(self.get(ParamId::ModEnvelopeTriggerMode))
5017 }
5018
5019 pub fn set_mod_envelope_trigger_mode(&mut self, value: EnvelopeTrigger) {
5021 self.set_clamped(ParamId::ModEnvelopeTriggerMode, value.raw());
5022 }
5023
5024 #[must_use]
5028 pub fn mod_envelope_attack_curve(&self) -> u8 {
5029 self.get(ParamId::ModEnvelopeAttackCurve)
5030 }
5031
5032 pub fn set_mod_envelope_attack_curve(&mut self, value: u8) {
5034 self.set_clamped(ParamId::ModEnvelopeAttackCurve, value);
5035 }
5036
5037 #[must_use]
5041 pub fn mod_envelope_decay_curve(&self) -> u8 {
5042 self.get(ParamId::ModEnvelopeDecayCurve)
5043 }
5044
5045 pub fn set_mod_envelope_decay_curve(&mut self, value: u8) {
5047 self.set_clamped(ParamId::ModEnvelopeDecayCurve, value);
5048 }
5049
5050 #[must_use]
5054 pub fn mod_envelope_sustain_curve(&self) -> u8 {
5055 self.get(ParamId::ModEnvelopeSustainCurve)
5056 }
5057
5058 pub fn set_mod_envelope_sustain_curve(&mut self, value: u8) {
5060 self.set_clamped(ParamId::ModEnvelopeSustainCurve, value);
5061 }
5062
5063 #[must_use]
5067 pub fn mod_envelope_release_curve(&self) -> u8 {
5068 self.get(ParamId::ModEnvelopeReleaseCurve)
5069 }
5070
5071 pub fn set_mod_envelope_release_curve(&mut self, value: u8) {
5073 self.set_clamped(ParamId::ModEnvelopeReleaseCurve, value);
5074 }
5075
5076 #[must_use]
5080 pub fn vca_level(&self) -> u8 {
5081 self.get(ParamId::VcaLevel)
5082 }
5083
5084 pub fn set_vca_level(&mut self, value: u8) {
5086 self.set_clamped(ParamId::VcaLevel, value);
5087 }
5088
5089 #[must_use]
5093 pub fn vca_envelope_depth(&self) -> u8 {
5094 self.get(ParamId::VcaEnvelopeDepth)
5095 }
5096
5097 pub fn set_vca_envelope_depth(&mut self, value: u8) {
5099 self.set_clamped(ParamId::VcaEnvelopeDepth, value);
5100 }
5101
5102 #[must_use]
5106 pub fn vca_envelope_velocity_sensitivity(&self) -> u8 {
5107 self.get(ParamId::VcaEnvelopeVelocitySensitivity)
5108 }
5109
5110 pub fn set_vca_envelope_velocity_sensitivity(&mut self, value: u8) {
5112 self.set_clamped(ParamId::VcaEnvelopeVelocitySensitivity, value);
5113 }
5114
5115 #[must_use]
5119 pub fn vca_pan_spread(&self) -> u8 {
5120 self.get(ParamId::VcaPanSpread)
5121 }
5122
5123 pub fn set_vca_pan_spread(&mut self, value: u8) {
5125 self.set_clamped(ParamId::VcaPanSpread, value);
5126 }
5127
5128 #[must_use]
5134 pub fn voice_priority_mode(&self) -> Option<VoicePriority> {
5135 VoicePriority::from_raw(self.get(ParamId::VoicePriorityMode))
5136 }
5137
5138 pub fn set_voice_priority_mode(&mut self, value: VoicePriority) {
5140 self.set_clamped(ParamId::VoicePriorityMode, value.raw());
5141 }
5142
5143 #[must_use]
5149 pub fn polyphony_mode(&self) -> Option<PolyphonyMode> {
5150 PolyphonyMode::from_raw(self.get(ParamId::PolyphonyMode))
5151 }
5152
5153 pub fn set_polyphony_mode(&mut self, value: PolyphonyMode) {
5155 self.set_clamped(ParamId::PolyphonyMode, value.raw());
5156 }
5157
5158 #[must_use]
5164 pub fn envelope_trigger_mode(&self) -> Option<KeyAssignMode> {
5165 KeyAssignMode::from_raw(self.get(ParamId::EnvelopeTriggerMode))
5166 }
5167
5168 pub fn set_envelope_trigger_mode(&mut self, value: KeyAssignMode) {
5170 self.set_clamped(ParamId::EnvelopeTriggerMode, value.raw());
5171 }
5172
5173 #[must_use]
5177 pub fn unison_detune(&self) -> u8 {
5178 self.get(ParamId::UnisonDetune)
5179 }
5180
5181 pub fn set_unison_detune(&mut self, value: u8) {
5183 self.set_clamped(ParamId::UnisonDetune, value);
5184 }
5185
5186 #[must_use]
5190 pub fn voice_drift(&self) -> u8 {
5191 self.get(ParamId::VoiceDrift)
5192 }
5193
5194 pub fn set_voice_drift(&mut self, value: u8) {
5196 self.set_clamped(ParamId::VoiceDrift, value);
5197 }
5198
5199 #[must_use]
5203 pub fn parameter_drift(&self) -> u8 {
5204 self.get(ParamId::ParameterDrift)
5205 }
5206
5207 pub fn set_parameter_drift(&mut self, value: u8) {
5209 self.set_clamped(ParamId::ParameterDrift, value);
5210 }
5211
5212 #[must_use]
5216 pub fn drift_rate(&self) -> u8 {
5217 self.get(ParamId::DriftRate)
5218 }
5219
5220 pub fn set_drift_rate(&mut self, value: u8) {
5222 self.set_clamped(ParamId::DriftRate, value);
5223 }
5224
5225 #[must_use]
5229 pub fn osc_portamento_balance(&self) -> u8 {
5230 self.get(ParamId::OscPortamentoBalance)
5231 }
5232
5233 pub fn set_osc_portamento_balance(&mut self, value: u8) {
5235 self.set_clamped(ParamId::OscPortamentoBalance, value);
5236 }
5237
5238 #[must_use]
5242 pub fn osc_key_down_reset(&self) -> bool {
5243 self.get(ParamId::OscKeyDownReset) != 0
5244 }
5245
5246 pub fn set_osc_key_down_reset(&mut self, value: bool) {
5248 self.set_clamped(ParamId::OscKeyDownReset, u8::from(value));
5249 }
5250
5251 #[must_use]
5257 pub fn mod1_source(&self) -> Option<ModSource> {
5258 ModSource::from_raw(self.get(ParamId::Mod1Source))
5259 }
5260
5261 pub fn set_mod1_source(&mut self, value: ModSource) {
5263 self.set_clamped(ParamId::Mod1Source, value.raw());
5264 }
5265
5266 #[must_use]
5272 pub fn mod1_destination(&self) -> Option<ModDestination> {
5273 ModDestination::from_raw(self.get(ParamId::Mod1Destination))
5274 }
5275
5276 pub fn set_mod1_destination(&mut self, value: ModDestination) {
5278 self.set_clamped(ParamId::Mod1Destination, value.raw());
5279 }
5280
5281 #[must_use]
5285 pub fn mod1_depth(&self) -> u8 {
5286 self.get(ParamId::Mod1Depth)
5287 }
5288
5289 pub fn set_mod1_depth(&mut self, value: u8) {
5291 self.set_clamped(ParamId::Mod1Depth, value);
5292 }
5293
5294 #[must_use]
5300 pub fn mod2_source(&self) -> Option<ModSource> {
5301 ModSource::from_raw(self.get(ParamId::Mod2Source))
5302 }
5303
5304 pub fn set_mod2_source(&mut self, value: ModSource) {
5306 self.set_clamped(ParamId::Mod2Source, value.raw());
5307 }
5308
5309 #[must_use]
5315 pub fn mod2_destination(&self) -> Option<ModDestination> {
5316 ModDestination::from_raw(self.get(ParamId::Mod2Destination))
5317 }
5318
5319 pub fn set_mod2_destination(&mut self, value: ModDestination) {
5321 self.set_clamped(ParamId::Mod2Destination, value.raw());
5322 }
5323
5324 #[must_use]
5328 pub fn mod2_depth(&self) -> u8 {
5329 self.get(ParamId::Mod2Depth)
5330 }
5331
5332 pub fn set_mod2_depth(&mut self, value: u8) {
5334 self.set_clamped(ParamId::Mod2Depth, value);
5335 }
5336
5337 #[must_use]
5343 pub fn mod3_source(&self) -> Option<ModSource> {
5344 ModSource::from_raw(self.get(ParamId::Mod3Source))
5345 }
5346
5347 pub fn set_mod3_source(&mut self, value: ModSource) {
5349 self.set_clamped(ParamId::Mod3Source, value.raw());
5350 }
5351
5352 #[must_use]
5358 pub fn mod3_destination(&self) -> Option<ModDestination> {
5359 ModDestination::from_raw(self.get(ParamId::Mod3Destination))
5360 }
5361
5362 pub fn set_mod3_destination(&mut self, value: ModDestination) {
5364 self.set_clamped(ParamId::Mod3Destination, value.raw());
5365 }
5366
5367 #[must_use]
5371 pub fn mod3_depth(&self) -> u8 {
5372 self.get(ParamId::Mod3Depth)
5373 }
5374
5375 pub fn set_mod3_depth(&mut self, value: u8) {
5377 self.set_clamped(ParamId::Mod3Depth, value);
5378 }
5379
5380 #[must_use]
5386 pub fn mod4_source(&self) -> Option<ModSource> {
5387 ModSource::from_raw(self.get(ParamId::Mod4Source))
5388 }
5389
5390 pub fn set_mod4_source(&mut self, value: ModSource) {
5392 self.set_clamped(ParamId::Mod4Source, value.raw());
5393 }
5394
5395 #[must_use]
5401 pub fn mod4_destination(&self) -> Option<ModDestination> {
5402 ModDestination::from_raw(self.get(ParamId::Mod4Destination))
5403 }
5404
5405 pub fn set_mod4_destination(&mut self, value: ModDestination) {
5407 self.set_clamped(ParamId::Mod4Destination, value.raw());
5408 }
5409
5410 #[must_use]
5414 pub fn mod4_depth(&self) -> u8 {
5415 self.get(ParamId::Mod4Depth)
5416 }
5417
5418 pub fn set_mod4_depth(&mut self, value: u8) {
5420 self.set_clamped(ParamId::Mod4Depth, value);
5421 }
5422
5423 #[must_use]
5429 pub fn mod5_source(&self) -> Option<ModSource> {
5430 ModSource::from_raw(self.get(ParamId::Mod5Source))
5431 }
5432
5433 pub fn set_mod5_source(&mut self, value: ModSource) {
5435 self.set_clamped(ParamId::Mod5Source, value.raw());
5436 }
5437
5438 #[must_use]
5444 pub fn mod5_destination(&self) -> Option<ModDestination> {
5445 ModDestination::from_raw(self.get(ParamId::Mod5Destination))
5446 }
5447
5448 pub fn set_mod5_destination(&mut self, value: ModDestination) {
5450 self.set_clamped(ParamId::Mod5Destination, value.raw());
5451 }
5452
5453 #[must_use]
5457 pub fn mod5_depth(&self) -> u8 {
5458 self.get(ParamId::Mod5Depth)
5459 }
5460
5461 pub fn set_mod5_depth(&mut self, value: u8) {
5463 self.set_clamped(ParamId::Mod5Depth, value);
5464 }
5465
5466 #[must_use]
5472 pub fn mod6_source(&self) -> Option<ModSource> {
5473 ModSource::from_raw(self.get(ParamId::Mod6Source))
5474 }
5475
5476 pub fn set_mod6_source(&mut self, value: ModSource) {
5478 self.set_clamped(ParamId::Mod6Source, value.raw());
5479 }
5480
5481 #[must_use]
5487 pub fn mod6_destination(&self) -> Option<ModDestination> {
5488 ModDestination::from_raw(self.get(ParamId::Mod6Destination))
5489 }
5490
5491 pub fn set_mod6_destination(&mut self, value: ModDestination) {
5493 self.set_clamped(ParamId::Mod6Destination, value.raw());
5494 }
5495
5496 #[must_use]
5500 pub fn mod6_depth(&self) -> u8 {
5501 self.get(ParamId::Mod6Depth)
5502 }
5503
5504 pub fn set_mod6_depth(&mut self, value: u8) {
5506 self.set_clamped(ParamId::Mod6Depth, value);
5507 }
5508
5509 #[must_use]
5515 pub fn mod7_source(&self) -> Option<ModSource> {
5516 ModSource::from_raw(self.get(ParamId::Mod7Source))
5517 }
5518
5519 pub fn set_mod7_source(&mut self, value: ModSource) {
5521 self.set_clamped(ParamId::Mod7Source, value.raw());
5522 }
5523
5524 #[must_use]
5530 pub fn mod7_destination(&self) -> Option<ModDestination> {
5531 ModDestination::from_raw(self.get(ParamId::Mod7Destination))
5532 }
5533
5534 pub fn set_mod7_destination(&mut self, value: ModDestination) {
5536 self.set_clamped(ParamId::Mod7Destination, value.raw());
5537 }
5538
5539 #[must_use]
5543 pub fn mod7_depth(&self) -> u8 {
5544 self.get(ParamId::Mod7Depth)
5545 }
5546
5547 pub fn set_mod7_depth(&mut self, value: u8) {
5549 self.set_clamped(ParamId::Mod7Depth, value);
5550 }
5551
5552 #[must_use]
5558 pub fn mod8_source(&self) -> Option<ModSource> {
5559 ModSource::from_raw(self.get(ParamId::Mod8Source))
5560 }
5561
5562 pub fn set_mod8_source(&mut self, value: ModSource) {
5564 self.set_clamped(ParamId::Mod8Source, value.raw());
5565 }
5566
5567 #[must_use]
5573 pub fn mod8_destination(&self) -> Option<ModDestination> {
5574 ModDestination::from_raw(self.get(ParamId::Mod8Destination))
5575 }
5576
5577 pub fn set_mod8_destination(&mut self, value: ModDestination) {
5579 self.set_clamped(ParamId::Mod8Destination, value.raw());
5580 }
5581
5582 #[must_use]
5586 pub fn mod8_depth(&self) -> u8 {
5587 self.get(ParamId::Mod8Depth)
5588 }
5589
5590 pub fn set_mod8_depth(&mut self, value: u8) {
5592 self.set_clamped(ParamId::Mod8Depth, value);
5593 }
5594
5595 #[must_use]
5599 pub fn ctrl_sequencer_enable(&self) -> bool {
5600 self.get(ParamId::CtrlSequencerEnable) != 0
5601 }
5602
5603 pub fn set_ctrl_sequencer_enable(&mut self, value: bool) {
5605 self.set_clamped(ParamId::CtrlSequencerEnable, u8::from(value));
5606 }
5607
5608 #[must_use]
5612 pub fn ctrl_sequencer_clock_divider(&self) -> u8 {
5613 self.get(ParamId::CtrlSequencerClockDivider)
5614 }
5615
5616 pub fn set_ctrl_sequencer_clock_divider(&mut self, value: u8) {
5618 self.set_clamped(ParamId::CtrlSequencerClockDivider, value);
5619 }
5620
5621 #[must_use]
5625 pub fn sequence_length(&self) -> u8 {
5626 self.get(ParamId::SequenceLength)
5627 }
5628
5629 pub fn set_sequence_length(&mut self, value: u8) {
5631 self.set_clamped(ParamId::SequenceLength, value);
5632 }
5633
5634 #[must_use]
5638 pub fn sequencer_swing_timing(&self) -> u8 {
5639 self.get(ParamId::SequencerSwingTiming)
5640 }
5641
5642 pub fn set_sequencer_swing_timing(&mut self, value: u8) {
5644 self.set_clamped(ParamId::SequencerSwingTiming, value);
5645 }
5646
5647 #[must_use]
5653 pub fn key_sync_and_loop(&self) -> Option<SequencerSync> {
5654 SequencerSync::from_raw(self.get(ParamId::KeySyncAndLoop))
5655 }
5656
5657 pub fn set_key_sync_and_loop(&mut self, value: SequencerSync) {
5659 self.set_clamped(ParamId::KeySyncAndLoop, value.raw());
5660 }
5661
5662 #[must_use]
5666 pub fn slew_rate(&self) -> u8 {
5667 self.get(ParamId::SlewRate)
5668 }
5669
5670 pub fn set_slew_rate(&mut self, value: u8) {
5672 self.set_clamped(ParamId::SlewRate, value);
5673 }
5674
5675 #[must_use]
5679 pub fn seq_step_value1(&self) -> u8 {
5680 self.get(ParamId::SeqStepValue1)
5681 }
5682
5683 pub fn set_seq_step_value1(&mut self, value: u8) {
5685 self.set_clamped(ParamId::SeqStepValue1, value);
5686 }
5687
5688 #[must_use]
5692 pub fn seq_step_value2(&self) -> u8 {
5693 self.get(ParamId::SeqStepValue2)
5694 }
5695
5696 pub fn set_seq_step_value2(&mut self, value: u8) {
5698 self.set_clamped(ParamId::SeqStepValue2, value);
5699 }
5700
5701 #[must_use]
5705 pub fn seq_step_value3(&self) -> u8 {
5706 self.get(ParamId::SeqStepValue3)
5707 }
5708
5709 pub fn set_seq_step_value3(&mut self, value: u8) {
5711 self.set_clamped(ParamId::SeqStepValue3, value);
5712 }
5713
5714 #[must_use]
5718 pub fn seq_step_value4(&self) -> u8 {
5719 self.get(ParamId::SeqStepValue4)
5720 }
5721
5722 pub fn set_seq_step_value4(&mut self, value: u8) {
5724 self.set_clamped(ParamId::SeqStepValue4, value);
5725 }
5726
5727 #[must_use]
5731 pub fn seq_step_value5(&self) -> u8 {
5732 self.get(ParamId::SeqStepValue5)
5733 }
5734
5735 pub fn set_seq_step_value5(&mut self, value: u8) {
5737 self.set_clamped(ParamId::SeqStepValue5, value);
5738 }
5739
5740 #[must_use]
5744 pub fn seq_step_value6(&self) -> u8 {
5745 self.get(ParamId::SeqStepValue6)
5746 }
5747
5748 pub fn set_seq_step_value6(&mut self, value: u8) {
5750 self.set_clamped(ParamId::SeqStepValue6, value);
5751 }
5752
5753 #[must_use]
5757 pub fn seq_step_value7(&self) -> u8 {
5758 self.get(ParamId::SeqStepValue7)
5759 }
5760
5761 pub fn set_seq_step_value7(&mut self, value: u8) {
5763 self.set_clamped(ParamId::SeqStepValue7, value);
5764 }
5765
5766 #[must_use]
5770 pub fn seq_step_value8(&self) -> u8 {
5771 self.get(ParamId::SeqStepValue8)
5772 }
5773
5774 pub fn set_seq_step_value8(&mut self, value: u8) {
5776 self.set_clamped(ParamId::SeqStepValue8, value);
5777 }
5778
5779 #[must_use]
5783 pub fn seq_step_value9(&self) -> u8 {
5784 self.get(ParamId::SeqStepValue9)
5785 }
5786
5787 pub fn set_seq_step_value9(&mut self, value: u8) {
5789 self.set_clamped(ParamId::SeqStepValue9, value);
5790 }
5791
5792 #[must_use]
5796 pub fn seq_step_value10(&self) -> u8 {
5797 self.get(ParamId::SeqStepValue10)
5798 }
5799
5800 pub fn set_seq_step_value10(&mut self, value: u8) {
5802 self.set_clamped(ParamId::SeqStepValue10, value);
5803 }
5804
5805 #[must_use]
5809 pub fn seq_step_value11(&self) -> u8 {
5810 self.get(ParamId::SeqStepValue11)
5811 }
5812
5813 pub fn set_seq_step_value11(&mut self, value: u8) {
5815 self.set_clamped(ParamId::SeqStepValue11, value);
5816 }
5817
5818 #[must_use]
5822 pub fn seq_step_value12(&self) -> u8 {
5823 self.get(ParamId::SeqStepValue12)
5824 }
5825
5826 pub fn set_seq_step_value12(&mut self, value: u8) {
5828 self.set_clamped(ParamId::SeqStepValue12, value);
5829 }
5830
5831 #[must_use]
5835 pub fn seq_step_value13(&self) -> u8 {
5836 self.get(ParamId::SeqStepValue13)
5837 }
5838
5839 pub fn set_seq_step_value13(&mut self, value: u8) {
5841 self.set_clamped(ParamId::SeqStepValue13, value);
5842 }
5843
5844 #[must_use]
5848 pub fn seq_step_value14(&self) -> u8 {
5849 self.get(ParamId::SeqStepValue14)
5850 }
5851
5852 pub fn set_seq_step_value14(&mut self, value: u8) {
5854 self.set_clamped(ParamId::SeqStepValue14, value);
5855 }
5856
5857 #[must_use]
5861 pub fn seq_step_value15(&self) -> u8 {
5862 self.get(ParamId::SeqStepValue15)
5863 }
5864
5865 pub fn set_seq_step_value15(&mut self, value: u8) {
5867 self.set_clamped(ParamId::SeqStepValue15, value);
5868 }
5869
5870 #[must_use]
5874 pub fn seq_step_value16(&self) -> u8 {
5875 self.get(ParamId::SeqStepValue16)
5876 }
5877
5878 pub fn set_seq_step_value16(&mut self, value: u8) {
5880 self.set_clamped(ParamId::SeqStepValue16, value);
5881 }
5882
5883 #[must_use]
5887 pub fn seq_step_value17(&self) -> u8 {
5888 self.get(ParamId::SeqStepValue17)
5889 }
5890
5891 pub fn set_seq_step_value17(&mut self, value: u8) {
5893 self.set_clamped(ParamId::SeqStepValue17, value);
5894 }
5895
5896 #[must_use]
5900 pub fn seq_step_value18(&self) -> u8 {
5901 self.get(ParamId::SeqStepValue18)
5902 }
5903
5904 pub fn set_seq_step_value18(&mut self, value: u8) {
5906 self.set_clamped(ParamId::SeqStepValue18, value);
5907 }
5908
5909 #[must_use]
5913 pub fn seq_step_value19(&self) -> u8 {
5914 self.get(ParamId::SeqStepValue19)
5915 }
5916
5917 pub fn set_seq_step_value19(&mut self, value: u8) {
5919 self.set_clamped(ParamId::SeqStepValue19, value);
5920 }
5921
5922 #[must_use]
5926 pub fn seq_step_value20(&self) -> u8 {
5927 self.get(ParamId::SeqStepValue20)
5928 }
5929
5930 pub fn set_seq_step_value20(&mut self, value: u8) {
5932 self.set_clamped(ParamId::SeqStepValue20, value);
5933 }
5934
5935 #[must_use]
5939 pub fn seq_step_value21(&self) -> u8 {
5940 self.get(ParamId::SeqStepValue21)
5941 }
5942
5943 pub fn set_seq_step_value21(&mut self, value: u8) {
5945 self.set_clamped(ParamId::SeqStepValue21, value);
5946 }
5947
5948 #[must_use]
5952 pub fn seq_step_value22(&self) -> u8 {
5953 self.get(ParamId::SeqStepValue22)
5954 }
5955
5956 pub fn set_seq_step_value22(&mut self, value: u8) {
5958 self.set_clamped(ParamId::SeqStepValue22, value);
5959 }
5960
5961 #[must_use]
5965 pub fn seq_step_value23(&self) -> u8 {
5966 self.get(ParamId::SeqStepValue23)
5967 }
5968
5969 pub fn set_seq_step_value23(&mut self, value: u8) {
5971 self.set_clamped(ParamId::SeqStepValue23, value);
5972 }
5973
5974 #[must_use]
5978 pub fn seq_step_value24(&self) -> u8 {
5979 self.get(ParamId::SeqStepValue24)
5980 }
5981
5982 pub fn set_seq_step_value24(&mut self, value: u8) {
5984 self.set_clamped(ParamId::SeqStepValue24, value);
5985 }
5986
5987 #[must_use]
5991 pub fn seq_step_value25(&self) -> u8 {
5992 self.get(ParamId::SeqStepValue25)
5993 }
5994
5995 pub fn set_seq_step_value25(&mut self, value: u8) {
5997 self.set_clamped(ParamId::SeqStepValue25, value);
5998 }
5999
6000 #[must_use]
6004 pub fn seq_step_value26(&self) -> u8 {
6005 self.get(ParamId::SeqStepValue26)
6006 }
6007
6008 pub fn set_seq_step_value26(&mut self, value: u8) {
6010 self.set_clamped(ParamId::SeqStepValue26, value);
6011 }
6012
6013 #[must_use]
6017 pub fn seq_step_value27(&self) -> u8 {
6018 self.get(ParamId::SeqStepValue27)
6019 }
6020
6021 pub fn set_seq_step_value27(&mut self, value: u8) {
6023 self.set_clamped(ParamId::SeqStepValue27, value);
6024 }
6025
6026 #[must_use]
6030 pub fn seq_step_value28(&self) -> u8 {
6031 self.get(ParamId::SeqStepValue28)
6032 }
6033
6034 pub fn set_seq_step_value28(&mut self, value: u8) {
6036 self.set_clamped(ParamId::SeqStepValue28, value);
6037 }
6038
6039 #[must_use]
6043 pub fn seq_step_value29(&self) -> u8 {
6044 self.get(ParamId::SeqStepValue29)
6045 }
6046
6047 pub fn set_seq_step_value29(&mut self, value: u8) {
6049 self.set_clamped(ParamId::SeqStepValue29, value);
6050 }
6051
6052 #[must_use]
6056 pub fn seq_step_value30(&self) -> u8 {
6057 self.get(ParamId::SeqStepValue30)
6058 }
6059
6060 pub fn set_seq_step_value30(&mut self, value: u8) {
6062 self.set_clamped(ParamId::SeqStepValue30, value);
6063 }
6064
6065 #[must_use]
6069 pub fn seq_step_value31(&self) -> u8 {
6070 self.get(ParamId::SeqStepValue31)
6071 }
6072
6073 pub fn set_seq_step_value31(&mut self, value: u8) {
6075 self.set_clamped(ParamId::SeqStepValue31, value);
6076 }
6077
6078 #[must_use]
6082 pub fn seq_step_value32(&self) -> u8 {
6083 self.get(ParamId::SeqStepValue32)
6084 }
6085
6086 pub fn set_seq_step_value32(&mut self, value: u8) {
6088 self.set_clamped(ParamId::SeqStepValue32, value);
6089 }
6090
6091 #[must_use]
6095 pub fn arp_on_off(&self) -> bool {
6096 self.get(ParamId::ArpOnOff) != 0
6097 }
6098
6099 pub fn set_arp_on_off(&mut self, value: bool) {
6101 self.set_clamped(ParamId::ArpOnOff, u8::from(value));
6102 }
6103
6104 #[must_use]
6110 pub fn arp_mode(&self) -> Option<ArpMode> {
6111 ArpMode::from_raw(self.get(ParamId::ArpMode))
6112 }
6113
6114 pub fn set_arp_mode(&mut self, value: ArpMode) {
6116 self.set_clamped(ParamId::ArpMode, value.raw());
6117 }
6118
6119 #[must_use]
6123 pub fn arp_rate_tempo(&self) -> u8 {
6124 self.get(ParamId::ArpRateTempo)
6125 }
6126
6127 pub fn set_arp_rate_tempo(&mut self, value: u8) {
6129 self.set_clamped(ParamId::ArpRateTempo, value);
6130 }
6131
6132 #[must_use]
6136 pub fn arp_clock(&self) -> u8 {
6137 self.get(ParamId::ArpClock)
6138 }
6139
6140 pub fn set_arp_clock(&mut self, value: u8) {
6142 self.set_clamped(ParamId::ArpClock, value);
6143 }
6144
6145 #[must_use]
6149 pub fn arp_key_sync(&self) -> bool {
6150 self.get(ParamId::ArpKeySync) != 0
6151 }
6152
6153 pub fn set_arp_key_sync(&mut self, value: bool) {
6155 self.set_clamped(ParamId::ArpKeySync, u8::from(value));
6156 }
6157
6158 #[must_use]
6162 pub fn arp_gate_time(&self) -> u8 {
6163 self.get(ParamId::ArpGateTime)
6164 }
6165
6166 pub fn set_arp_gate_time(&mut self, value: u8) {
6168 self.set_clamped(ParamId::ArpGateTime, value);
6169 }
6170
6171 #[must_use]
6175 pub fn arp_hold(&self) -> bool {
6176 self.get(ParamId::ArpHold) != 0
6177 }
6178
6179 pub fn set_arp_hold(&mut self, value: bool) {
6181 self.set_clamped(ParamId::ArpHold, u8::from(value));
6182 }
6183
6184 #[must_use]
6188 pub fn arp_pattern(&self) -> u8 {
6189 self.get(ParamId::ArpPattern)
6190 }
6191
6192 pub fn set_arp_pattern(&mut self, value: u8) {
6194 self.set_clamped(ParamId::ArpPattern, value);
6195 }
6196
6197 #[must_use]
6201 pub fn arp_swing(&self) -> u8 {
6202 self.get(ParamId::ArpSwing)
6203 }
6204
6205 pub fn set_arp_swing(&mut self, value: u8) {
6207 self.set_clamped(ParamId::ArpSwing, value);
6208 }
6209
6210 #[must_use]
6214 pub fn arp_octaves(&self) -> u8 {
6215 self.get(ParamId::ArpOctaves)
6216 }
6217
6218 pub fn set_arp_octaves(&mut self, value: u8) {
6220 self.set_clamped(ParamId::ArpOctaves, value);
6221 }
6222
6223 #[must_use]
6229 pub fn fx_routing(&self) -> Option<FxRouting> {
6230 FxRouting::from_raw(self.get(ParamId::FxRouting))
6231 }
6232
6233 pub fn set_fx_routing(&mut self, value: FxRouting) {
6235 self.set_clamped(ParamId::FxRouting, value.raw());
6236 }
6237
6238 #[must_use]
6244 pub fn fx1_type(&self) -> Option<FxType> {
6245 FxType::from_raw(self.get(ParamId::Fx1Type))
6246 }
6247
6248 pub fn set_fx1_type(&mut self, value: FxType) {
6250 self.set_clamped(ParamId::Fx1Type, value.raw());
6251 }
6252
6253 #[must_use]
6257 pub fn fx1_param1(&self) -> u8 {
6258 self.get(ParamId::Fx1Param1)
6259 }
6260
6261 pub fn set_fx1_param1(&mut self, value: u8) {
6263 self.set_clamped(ParamId::Fx1Param1, value);
6264 }
6265
6266 #[must_use]
6270 pub fn fx1_param2(&self) -> u8 {
6271 self.get(ParamId::Fx1Param2)
6272 }
6273
6274 pub fn set_fx1_param2(&mut self, value: u8) {
6276 self.set_clamped(ParamId::Fx1Param2, value);
6277 }
6278
6279 #[must_use]
6283 pub fn fx1_param3(&self) -> u8 {
6284 self.get(ParamId::Fx1Param3)
6285 }
6286
6287 pub fn set_fx1_param3(&mut self, value: u8) {
6289 self.set_clamped(ParamId::Fx1Param3, value);
6290 }
6291
6292 #[must_use]
6296 pub fn fx1_param4(&self) -> u8 {
6297 self.get(ParamId::Fx1Param4)
6298 }
6299
6300 pub fn set_fx1_param4(&mut self, value: u8) {
6302 self.set_clamped(ParamId::Fx1Param4, value);
6303 }
6304
6305 #[must_use]
6309 pub fn fx1_param5(&self) -> u8 {
6310 self.get(ParamId::Fx1Param5)
6311 }
6312
6313 pub fn set_fx1_param5(&mut self, value: u8) {
6315 self.set_clamped(ParamId::Fx1Param5, value);
6316 }
6317
6318 #[must_use]
6322 pub fn fx1_param6(&self) -> u8 {
6323 self.get(ParamId::Fx1Param6)
6324 }
6325
6326 pub fn set_fx1_param6(&mut self, value: u8) {
6328 self.set_clamped(ParamId::Fx1Param6, value);
6329 }
6330
6331 #[must_use]
6335 pub fn fx1_param7(&self) -> u8 {
6336 self.get(ParamId::Fx1Param7)
6337 }
6338
6339 pub fn set_fx1_param7(&mut self, value: u8) {
6341 self.set_clamped(ParamId::Fx1Param7, value);
6342 }
6343
6344 #[must_use]
6348 pub fn fx1_param8(&self) -> u8 {
6349 self.get(ParamId::Fx1Param8)
6350 }
6351
6352 pub fn set_fx1_param8(&mut self, value: u8) {
6354 self.set_clamped(ParamId::Fx1Param8, value);
6355 }
6356
6357 #[must_use]
6361 pub fn fx1_param9(&self) -> u8 {
6362 self.get(ParamId::Fx1Param9)
6363 }
6364
6365 pub fn set_fx1_param9(&mut self, value: u8) {
6367 self.set_clamped(ParamId::Fx1Param9, value);
6368 }
6369
6370 #[must_use]
6374 pub fn fx1_param10(&self) -> u8 {
6375 self.get(ParamId::Fx1Param10)
6376 }
6377
6378 pub fn set_fx1_param10(&mut self, value: u8) {
6380 self.set_clamped(ParamId::Fx1Param10, value);
6381 }
6382
6383 #[must_use]
6387 pub fn fx1_param11(&self) -> u8 {
6388 self.get(ParamId::Fx1Param11)
6389 }
6390
6391 pub fn set_fx1_param11(&mut self, value: u8) {
6393 self.set_clamped(ParamId::Fx1Param11, value);
6394 }
6395
6396 #[must_use]
6400 pub fn fx1_param12(&self) -> u8 {
6401 self.get(ParamId::Fx1Param12)
6402 }
6403
6404 pub fn set_fx1_param12(&mut self, value: u8) {
6406 self.set_clamped(ParamId::Fx1Param12, value);
6407 }
6408
6409 #[must_use]
6415 pub fn fx2_type(&self) -> Option<FxType> {
6416 FxType::from_raw(self.get(ParamId::Fx2Type))
6417 }
6418
6419 pub fn set_fx2_type(&mut self, value: FxType) {
6421 self.set_clamped(ParamId::Fx2Type, value.raw());
6422 }
6423
6424 #[must_use]
6428 pub fn fx2_param1(&self) -> u8 {
6429 self.get(ParamId::Fx2Param1)
6430 }
6431
6432 pub fn set_fx2_param1(&mut self, value: u8) {
6434 self.set_clamped(ParamId::Fx2Param1, value);
6435 }
6436
6437 #[must_use]
6441 pub fn fx2_param2(&self) -> u8 {
6442 self.get(ParamId::Fx2Param2)
6443 }
6444
6445 pub fn set_fx2_param2(&mut self, value: u8) {
6447 self.set_clamped(ParamId::Fx2Param2, value);
6448 }
6449
6450 #[must_use]
6454 pub fn fx2_param3(&self) -> u8 {
6455 self.get(ParamId::Fx2Param3)
6456 }
6457
6458 pub fn set_fx2_param3(&mut self, value: u8) {
6460 self.set_clamped(ParamId::Fx2Param3, value);
6461 }
6462
6463 #[must_use]
6467 pub fn fx2_param4(&self) -> u8 {
6468 self.get(ParamId::Fx2Param4)
6469 }
6470
6471 pub fn set_fx2_param4(&mut self, value: u8) {
6473 self.set_clamped(ParamId::Fx2Param4, value);
6474 }
6475
6476 #[must_use]
6480 pub fn fx2_param5(&self) -> u8 {
6481 self.get(ParamId::Fx2Param5)
6482 }
6483
6484 pub fn set_fx2_param5(&mut self, value: u8) {
6486 self.set_clamped(ParamId::Fx2Param5, value);
6487 }
6488
6489 #[must_use]
6493 pub fn fx2_param6(&self) -> u8 {
6494 self.get(ParamId::Fx2Param6)
6495 }
6496
6497 pub fn set_fx2_param6(&mut self, value: u8) {
6499 self.set_clamped(ParamId::Fx2Param6, value);
6500 }
6501
6502 #[must_use]
6506 pub fn fx2_param7(&self) -> u8 {
6507 self.get(ParamId::Fx2Param7)
6508 }
6509
6510 pub fn set_fx2_param7(&mut self, value: u8) {
6512 self.set_clamped(ParamId::Fx2Param7, value);
6513 }
6514
6515 #[must_use]
6519 pub fn fx2_param8(&self) -> u8 {
6520 self.get(ParamId::Fx2Param8)
6521 }
6522
6523 pub fn set_fx2_param8(&mut self, value: u8) {
6525 self.set_clamped(ParamId::Fx2Param8, value);
6526 }
6527
6528 #[must_use]
6532 pub fn fx2_param9(&self) -> u8 {
6533 self.get(ParamId::Fx2Param9)
6534 }
6535
6536 pub fn set_fx2_param9(&mut self, value: u8) {
6538 self.set_clamped(ParamId::Fx2Param9, value);
6539 }
6540
6541 #[must_use]
6545 pub fn fx2_param10(&self) -> u8 {
6546 self.get(ParamId::Fx2Param10)
6547 }
6548
6549 pub fn set_fx2_param10(&mut self, value: u8) {
6551 self.set_clamped(ParamId::Fx2Param10, value);
6552 }
6553
6554 #[must_use]
6558 pub fn fx2_param11(&self) -> u8 {
6559 self.get(ParamId::Fx2Param11)
6560 }
6561
6562 pub fn set_fx2_param11(&mut self, value: u8) {
6564 self.set_clamped(ParamId::Fx2Param11, value);
6565 }
6566
6567 #[must_use]
6571 pub fn fx2_param12(&self) -> u8 {
6572 self.get(ParamId::Fx2Param12)
6573 }
6574
6575 pub fn set_fx2_param12(&mut self, value: u8) {
6577 self.set_clamped(ParamId::Fx2Param12, value);
6578 }
6579
6580 #[must_use]
6586 pub fn fx3_type(&self) -> Option<FxType> {
6587 FxType::from_raw(self.get(ParamId::Fx3Type))
6588 }
6589
6590 pub fn set_fx3_type(&mut self, value: FxType) {
6592 self.set_clamped(ParamId::Fx3Type, value.raw());
6593 }
6594
6595 #[must_use]
6599 pub fn fx3_param1(&self) -> u8 {
6600 self.get(ParamId::Fx3Param1)
6601 }
6602
6603 pub fn set_fx3_param1(&mut self, value: u8) {
6605 self.set_clamped(ParamId::Fx3Param1, value);
6606 }
6607
6608 #[must_use]
6612 pub fn fx3_param2(&self) -> u8 {
6613 self.get(ParamId::Fx3Param2)
6614 }
6615
6616 pub fn set_fx3_param2(&mut self, value: u8) {
6618 self.set_clamped(ParamId::Fx3Param2, value);
6619 }
6620
6621 #[must_use]
6625 pub fn fx3_param3(&self) -> u8 {
6626 self.get(ParamId::Fx3Param3)
6627 }
6628
6629 pub fn set_fx3_param3(&mut self, value: u8) {
6631 self.set_clamped(ParamId::Fx3Param3, value);
6632 }
6633
6634 #[must_use]
6638 pub fn fx3_param4(&self) -> u8 {
6639 self.get(ParamId::Fx3Param4)
6640 }
6641
6642 pub fn set_fx3_param4(&mut self, value: u8) {
6644 self.set_clamped(ParamId::Fx3Param4, value);
6645 }
6646
6647 #[must_use]
6651 pub fn fx3_param5(&self) -> u8 {
6652 self.get(ParamId::Fx3Param5)
6653 }
6654
6655 pub fn set_fx3_param5(&mut self, value: u8) {
6657 self.set_clamped(ParamId::Fx3Param5, value);
6658 }
6659
6660 #[must_use]
6664 pub fn fx3_param6(&self) -> u8 {
6665 self.get(ParamId::Fx3Param6)
6666 }
6667
6668 pub fn set_fx3_param6(&mut self, value: u8) {
6670 self.set_clamped(ParamId::Fx3Param6, value);
6671 }
6672
6673 #[must_use]
6677 pub fn fx3_param7(&self) -> u8 {
6678 self.get(ParamId::Fx3Param7)
6679 }
6680
6681 pub fn set_fx3_param7(&mut self, value: u8) {
6683 self.set_clamped(ParamId::Fx3Param7, value);
6684 }
6685
6686 #[must_use]
6690 pub fn fx3_param8(&self) -> u8 {
6691 self.get(ParamId::Fx3Param8)
6692 }
6693
6694 pub fn set_fx3_param8(&mut self, value: u8) {
6696 self.set_clamped(ParamId::Fx3Param8, value);
6697 }
6698
6699 #[must_use]
6703 pub fn fx3_param9(&self) -> u8 {
6704 self.get(ParamId::Fx3Param9)
6705 }
6706
6707 pub fn set_fx3_param9(&mut self, value: u8) {
6709 self.set_clamped(ParamId::Fx3Param9, value);
6710 }
6711
6712 #[must_use]
6716 pub fn fx3_param10(&self) -> u8 {
6717 self.get(ParamId::Fx3Param10)
6718 }
6719
6720 pub fn set_fx3_param10(&mut self, value: u8) {
6722 self.set_clamped(ParamId::Fx3Param10, value);
6723 }
6724
6725 #[must_use]
6729 pub fn fx3_param11(&self) -> u8 {
6730 self.get(ParamId::Fx3Param11)
6731 }
6732
6733 pub fn set_fx3_param11(&mut self, value: u8) {
6735 self.set_clamped(ParamId::Fx3Param11, value);
6736 }
6737
6738 #[must_use]
6742 pub fn fx3_param12(&self) -> u8 {
6743 self.get(ParamId::Fx3Param12)
6744 }
6745
6746 pub fn set_fx3_param12(&mut self, value: u8) {
6748 self.set_clamped(ParamId::Fx3Param12, value);
6749 }
6750
6751 #[must_use]
6757 pub fn fx4_type(&self) -> Option<FxType> {
6758 FxType::from_raw(self.get(ParamId::Fx4Type))
6759 }
6760
6761 pub fn set_fx4_type(&mut self, value: FxType) {
6763 self.set_clamped(ParamId::Fx4Type, value.raw());
6764 }
6765
6766 #[must_use]
6770 pub fn fx4_param1(&self) -> u8 {
6771 self.get(ParamId::Fx4Param1)
6772 }
6773
6774 pub fn set_fx4_param1(&mut self, value: u8) {
6776 self.set_clamped(ParamId::Fx4Param1, value);
6777 }
6778
6779 #[must_use]
6783 pub fn fx4_param2(&self) -> u8 {
6784 self.get(ParamId::Fx4Param2)
6785 }
6786
6787 pub fn set_fx4_param2(&mut self, value: u8) {
6789 self.set_clamped(ParamId::Fx4Param2, value);
6790 }
6791
6792 #[must_use]
6796 pub fn fx4_param3(&self) -> u8 {
6797 self.get(ParamId::Fx4Param3)
6798 }
6799
6800 pub fn set_fx4_param3(&mut self, value: u8) {
6802 self.set_clamped(ParamId::Fx4Param3, value);
6803 }
6804
6805 #[must_use]
6809 pub fn fx4_param4(&self) -> u8 {
6810 self.get(ParamId::Fx4Param4)
6811 }
6812
6813 pub fn set_fx4_param4(&mut self, value: u8) {
6815 self.set_clamped(ParamId::Fx4Param4, value);
6816 }
6817
6818 #[must_use]
6822 pub fn fx4_param5(&self) -> u8 {
6823 self.get(ParamId::Fx4Param5)
6824 }
6825
6826 pub fn set_fx4_param5(&mut self, value: u8) {
6828 self.set_clamped(ParamId::Fx4Param5, value);
6829 }
6830
6831 #[must_use]
6835 pub fn fx4_param6(&self) -> u8 {
6836 self.get(ParamId::Fx4Param6)
6837 }
6838
6839 pub fn set_fx4_param6(&mut self, value: u8) {
6841 self.set_clamped(ParamId::Fx4Param6, value);
6842 }
6843
6844 #[must_use]
6848 pub fn fx4_param7(&self) -> u8 {
6849 self.get(ParamId::Fx4Param7)
6850 }
6851
6852 pub fn set_fx4_param7(&mut self, value: u8) {
6854 self.set_clamped(ParamId::Fx4Param7, value);
6855 }
6856
6857 #[must_use]
6861 pub fn fx4_param8(&self) -> u8 {
6862 self.get(ParamId::Fx4Param8)
6863 }
6864
6865 pub fn set_fx4_param8(&mut self, value: u8) {
6867 self.set_clamped(ParamId::Fx4Param8, value);
6868 }
6869
6870 #[must_use]
6874 pub fn fx4_param9(&self) -> u8 {
6875 self.get(ParamId::Fx4Param9)
6876 }
6877
6878 pub fn set_fx4_param9(&mut self, value: u8) {
6880 self.set_clamped(ParamId::Fx4Param9, value);
6881 }
6882
6883 #[must_use]
6887 pub fn fx4_param10(&self) -> u8 {
6888 self.get(ParamId::Fx4Param10)
6889 }
6890
6891 pub fn set_fx4_param10(&mut self, value: u8) {
6893 self.set_clamped(ParamId::Fx4Param10, value);
6894 }
6895
6896 #[must_use]
6900 pub fn fx4_param11(&self) -> u8 {
6901 self.get(ParamId::Fx4Param11)
6902 }
6903
6904 pub fn set_fx4_param11(&mut self, value: u8) {
6906 self.set_clamped(ParamId::Fx4Param11, value);
6907 }
6908
6909 #[must_use]
6913 pub fn fx4_param12(&self) -> u8 {
6914 self.get(ParamId::Fx4Param12)
6915 }
6916
6917 pub fn set_fx4_param12(&mut self, value: u8) {
6919 self.set_clamped(ParamId::Fx4Param12, value);
6920 }
6921
6922 #[must_use]
6926 pub fn fx1_output_gain(&self) -> u8 {
6927 self.get(ParamId::Fx1OutputGain)
6928 }
6929
6930 pub fn set_fx1_output_gain(&mut self, value: u8) {
6932 self.set_clamped(ParamId::Fx1OutputGain, value);
6933 }
6934
6935 #[must_use]
6939 pub fn fx2_output_gain(&self) -> u8 {
6940 self.get(ParamId::Fx2OutputGain)
6941 }
6942
6943 pub fn set_fx2_output_gain(&mut self, value: u8) {
6945 self.set_clamped(ParamId::Fx2OutputGain, value);
6946 }
6947
6948 #[must_use]
6952 pub fn fx3_output_gain(&self) -> u8 {
6953 self.get(ParamId::Fx3OutputGain)
6954 }
6955
6956 pub fn set_fx3_output_gain(&mut self, value: u8) {
6958 self.set_clamped(ParamId::Fx3OutputGain, value);
6959 }
6960
6961 #[must_use]
6965 pub fn fx4_output_gain(&self) -> u8 {
6966 self.get(ParamId::Fx4OutputGain)
6967 }
6968
6969 pub fn set_fx4_output_gain(&mut self, value: u8) {
6971 self.set_clamped(ParamId::Fx4OutputGain, value);
6972 }
6973
6974 #[must_use]
6980 pub fn fx_mode(&self) -> Option<FxMode> {
6981 FxMode::from_raw(self.get(ParamId::FxMode))
6982 }
6983
6984 pub fn set_fx_mode(&mut self, value: FxMode) {
6986 self.set_clamped(ParamId::FxMode, value.raw());
6987 }
6988
6989 #[must_use]
6995 pub fn program_category(&self) -> Option<ProgramCategory> {
6996 ProgramCategory::from_raw(self.get(ParamId::ProgramCategory))
6997 }
6998
6999 pub fn set_program_category(&mut self, value: ProgramCategory) {
7001 self.set_clamped(ParamId::ProgramCategory, value.raw());
7002 }
7003
7004 #[must_use]
7008 pub fn program_transpose(&self) -> u8 {
7009 self.get(ParamId::ProgramTranspose)
7010 }
7011
7012 pub fn set_program_transpose(&mut self, value: u8) {
7014 self.set_clamped(ParamId::ProgramTranspose, value);
7015 }
7016}