Change channel/synth configuration methods (#93)

core/benches/send_events.rs

@@ -58,7 +58,6 @@ fn criterion_benchmark(c: &mut Criterion) {
         f.iter(|| {
             let init = ChannelInitOptions {
                 fade_out_killing: false,
-                ..Default::default()
             };
             let mut channel = VoiceChannel::new(init, stream_params, None);
             channel.process_event(ChannelEvent::Config(ChannelConfigEvent::SetSoundfonts(
@@ -76,7 +75,6 @@ fn criterion_benchmark(c: &mut Criterion) {
         f.iter(|| {
             let init = ChannelInitOptions {
                 fade_out_killing: true,
-                ..Default::default()
             };
             let mut channel = VoiceChannel::new(init, stream_params, None);
             channel.process_event(ChannelEvent::Config(ChannelConfigEvent::SetSoundfonts(
@@ -94,7 +92,6 @@ fn criterion_benchmark(c: &mut Criterion) {
         f.iter(|| {
             let init = ChannelInitOptions {
                 fade_out_killing: false,
-                ..Default::default()
             };
             let mut channel = VoiceChannel::new(init, stream_params, None);
             channel.process_event(ChannelEvent::Config(ChannelConfigEvent::SetSoundfonts(
@@ -112,7 +109,6 @@ fn criterion_benchmark(c: &mut Criterion) {
         f.iter(|| {
             let init = ChannelInitOptions {
                 fade_out_killing: true,
-                ..Default::default()
             };
             let mut channel = VoiceChannel::new(init, stream_params, None);
             channel.process_event(ChannelEvent::Config(ChannelConfigEvent::SetSoundfonts(

core/src/channel/channel_sf.rs

@@ -8,11 +8,16 @@ use crate::{
 
 use super::voice_spawner::VoiceSpawnerMatrix;
 
+#[derive(Default, PartialEq, Eq, Clone, Copy, Debug)]
+pub struct ProgramDescriptor {
+    pub bank: u8,
+    pub preset: u8,
+}
+
 pub struct ChannelSoundfont {
     soundfonts: Vec<Arc<dyn SoundfontBase>>,
     matrix: VoiceSpawnerMatrix,
-    curr_bank: u8,
-    curr_preset: u8,
+    curr_program: ProgramDescriptor,
 }
 
 impl Deref for ChannelSoundfont {
@@ -29,8 +34,7 @@ impl ChannelSoundfont {
         ChannelSoundfont {
             soundfonts: Vec::new(),
             matrix: VoiceSpawnerMatrix::new(),
-            curr_bank: 0,
-            curr_preset: 0,
+            curr_program: Default::default(),
         }
     }
 
@@ -41,10 +45,9 @@ impl ChannelSoundfont {
         }
     }
 
-    pub fn change_program(&mut self, bank: u8, preset: u8) {
-        if self.curr_bank != bank || self.curr_preset != preset {
-            self.curr_bank = bank;
-            self.curr_preset = preset;
+    pub fn change_program(&mut self, program: ProgramDescriptor) {
+        if self.curr_program != program {
+            self.curr_program = program;
             self.rebuild_matrix();
         }
     }
@@ -55,8 +58,8 @@ impl ChannelSoundfont {
         // if a preset/instr. has regions in any bank other than 0, all missing banks will be muted.
         // For drum patches the same applies with bank and preset switched.
 
-        let bank = self.curr_bank;
-        let preset = self.curr_preset;
+        let bank = self.curr_program.bank;
+        let preset = self.curr_program.preset;
 
         for k in 0..128u8 {
             for v in 0..128u8 {

core/src/channel/event.rs

@@ -28,6 +28,10 @@ pub enum ChannelConfigEvent {
 
     /// Sets the layer count for the soundfont
     SetLayerCount(Option<usize>),
+
+    /// Controls whether the channel will be standard or percussion.
+    /// Setting to `true` will make the channel only use percussion patches.
+    SetPercussionMode(bool),
 }
 
 /// MIDI events for a channel.

core/src/channel/mod.rs

@@ -92,12 +92,10 @@ struct ControlEventData {
     cutoff: Option<f32>,
     resonance: Option<f32>,
     expression: ValueLerp,
-    preset: u8,
-    bank: u8,
 }
 
 impl ControlEventData {
-    pub fn new_defaults(sample_rate: u32, drums_only: bool) -> Self {
+    pub fn new_defaults(sample_rate: u32) -> Self {
         ControlEventData {
             selected_lsb: -1,
             selected_msb: -1,
@@ -114,8 +112,6 @@ impl ControlEventData {
             cutoff: None,
             resonance: None,
             expression: ValueLerp::new(1.0, sample_rate),
-            preset: 0,
-            bank: if drums_only { 128 } else { 0 },
         }
     }
 }
@@ -130,19 +126,13 @@ pub struct ChannelInitOptions {
     ///
     /// Default: `false`
     pub fade_out_killing: bool,
-
-    /// If set to true, the channel will only use drum patches.
-    ///
-    /// Default: `false`
-    pub drums_only: bool,
 }
 
 #[allow(clippy::derivable_impls)]
 impl Default for ChannelInitOptions {
     fn default() -> Self {
         Self {
             fade_out_killing: false,
-            drums_only: false,
         }
     }
 }
@@ -173,7 +163,6 @@ pub struct VoiceChannel {
     threadpool: Option<Arc<rayon::ThreadPool>>,
 
     stream_params: AudioStreamParams,
-    options: ChannelInitOptions,
 
     /// The helper struct for keeping track of MIDI control event data
     control_event_data: ControlEventData,
@@ -216,12 +205,8 @@ impl VoiceChannel {
             threadpool,
 
             stream_params,
-            options,
 
-            control_event_data: ControlEventData::new_defaults(
-                stream_params.sample_rate,
-                options.drums_only,
-            ),
+            control_event_data: ControlEventData::new_defaults(stream_params.sample_rate),
             voice_control_data: VoiceControlData::new_defaults(),
 
             cutoff: MultiChannelBiQuad::new(
@@ -273,9 +258,7 @@ impl VoiceChannel {
     }
 
     fn push_key_events_and_render(&mut self, out: &mut [f32]) {
-        self.params
-            .channel_sf
-            .change_program(self.control_event_data.bank, self.control_event_data.preset);
+        self.params.load_program();
 
         out.fill(0.0);
         match self.threadpool.as_ref() {
@@ -332,9 +315,7 @@ impl VoiceChannel {
             ControlEvent::Raw(controller, value) => match controller {
                 0x00 => {
                     // Bank select
-                    if !self.options.drums_only {
-                        self.control_event_data.bank = value;
-                    }
+                    self.params.set_bank(value);
                 }
                 0x64 => {
                     self.control_event_data.selected_lsb = value as i8;
@@ -563,7 +544,7 @@ impl VoiceChannel {
                         self.process_control_event(control);
                     }
                     ChannelAudioEvent::ProgramChange(preset) => {
-                        self.control_event_data.preset = preset;
+                        self.params.set_preset(preset);
                     }
                 },
                 ChannelEvent::Config(config) => self.params.process_config_event(config),
@@ -579,8 +560,7 @@ impl VoiceChannel {
     }
 
     fn reset_control(&mut self) {
-        self.control_event_data =
-            ControlEventData::new_defaults(self.stream_params.sample_rate, self.options.drums_only);
+        self.control_event_data = ControlEventData::new_defaults(self.stream_params.sample_rate);
         self.voice_control_data = VoiceControlData::new_defaults();
         self.process_event(ChannelEvent::Audio(ChannelAudioEvent::ProgramChange(0)));
         self.propagate_voice_controls();

core/src/channel/params.rs

@@ -2,7 +2,10 @@ use std::sync::{atomic::AtomicU64, Arc};
 
 use crate::AudioStreamParams;
 
-use super::{channel_sf::ChannelSoundfont, ChannelConfigEvent};
+use super::{
+    channel_sf::{ChannelSoundfont, ProgramDescriptor},
+    ChannelConfigEvent,
+};
 
 /// Holds the statistics for an instance of VoiceChannel.
 #[derive(Debug, Clone)]
@@ -24,6 +27,7 @@ pub struct VoiceChannelParams {
     pub stats: VoiceChannelStats,
     pub layers: Option<usize>,
     pub channel_sf: ChannelSoundfont,
+    pub program: ProgramDescriptor,
     pub constant: VoiceChannelConst,
 }
 
@@ -48,6 +52,7 @@ impl VoiceChannelParams {
             stats: VoiceChannelStats::new(),
             layers: Some(4),
             channel_sf,
+            program: Default::default(),
             constant: VoiceChannelConst { stream_params },
         }
     }
@@ -60,8 +65,30 @@ impl VoiceChannelParams {
             ChannelConfigEvent::SetLayerCount(count) => {
                 self.layers = count;
             }
+            ChannelConfigEvent::SetPercussionMode(set) => {
+                if set {
+                    self.program.bank = 128;
+                } else {
+                    self.program.bank = 0;
+                }
+                self.channel_sf.change_program(self.program);
+            }
+        }
+    }
+
+    pub fn set_bank(&mut self, bank: u8) {
+        if self.program.bank != 128 {
+            self.program.bank = bank.min(127);
         }
     }
+
+    pub fn set_preset(&mut self, preset: u8) {
+        self.program.preset = preset.min(127);
+    }
+
+    pub fn load_program(&mut self) {
+        self.channel_sf.change_program(self.program);
+    }
 }
 
 impl VoiceChannelStatsReader {

core/src/channel_group/config.rs

@@ -1,5 +1,17 @@
 use crate::{channel::ChannelInitOptions, AudioStreamParams};
 
+/// Controls the channel format that will be used in the synthesizer.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum SynthFormat {
+    /// Standard MIDI format with 16 channels. Channel 10 will be used for percussion.
+    #[default]
+    MidiSingle,
+
+    /// Creates a custom number of channels with the default settings.
+    Custom { channels: u32 },
+}
+
 /// Defines the multithreading options for each task that supports it.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -69,16 +81,9 @@ pub struct ChannelGroupConfig {
     /// See the `ChannelInitOptions` documentation for more information.
     pub channel_init_options: ChannelInitOptions,
 
-    /// Amount of VoiceChannel objects to be created
-    /// (Number of MIDI channels)
-    /// The MIDI 1 spec uses 16 channels.
-    pub channel_count: u32,
-
-    /// A vector which specifies which of the created channels (indexes) will be used for drums.
-    ///
-    /// For example in a conventional 16 MIDI channel setup where channel 10 is used for
-    /// drums, the vector would be set as vec!\[9\] (counting from 0).
-    pub drums_channels: Vec<u32>,
+    /// Defines the format that the synthesizer will use. See the `SynthFormat`
+    /// documentation for more information.
+    pub format: SynthFormat,
 
     /// Parameters of the output audio.
     /// See the `AudioStreamParams` documentation for more information.

core/src/channel_group/events.rs

@@ -1,18 +1,14 @@
-use crate::channel::{ChannelAudioEvent, ChannelConfigEvent};
+use crate::channel::ChannelEvent;
 
 /// Wrapper enum for various events to be sent to a MIDI synthesizer.
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum SynthEvent {
-    /// An audio event to be sent to the specified channel.
-    /// See `ChannelAudioEvent` documentation for more information.
-    Channel(u32, ChannelAudioEvent),
+    /// A channel event to be sent to the specified channel.
+    /// See `ChannelEvent` documentation for more information.
+    Channel(u32, ChannelEvent),
 
-    /// An audio event to be sent to all available channels.
+    /// A channel event to be sent to all available channels.
     /// See `ChannelAudioEvent` documentation for more information.
-    AllChannels(ChannelAudioEvent),
-
-    /// Configuration event for all channels.
-    /// See `ChannelConfigEvent` documentation for more information.
-    ChannelConfig(ChannelConfigEvent),
+    AllChannels(ChannelEvent),
 }