Fine-grained midi resource allocation

Author: gridbugs

caw/examples/live_example.rs

@@ -50,8 +50,8 @@ fn main() {
     ]
     .into_iter()
     .sum::<Sig<_>>()
-        * 0.5) //knob("drum vol").build())
-        .shared();
+        * knob("drum vol").build())
+    .shared();
     out.set_channel(|channel| {
         let voice = key_events.clone().mono_voice();
         let (note, gate) = key_looper(voice.triggered_note(), clock.clone())

midi-udp-widgets-app-lib/src/button.rs

@@ -15,12 +15,18 @@ lazy_static! {
 }
 
 fn new_button(title: String) -> Sig<SigShared<Button>> {
+    let (channel, key) = midi::alloc_key();
+    let note = Note::from_midi_index(key);
     BY_TITLE.get_or_insert(title.as_str(), || {
-        let widget =
-            Widget::new(title.clone(), midi::alloc_channel(), "button", vec![])
-                .unwrap();
+        let widget = Widget::new(
+            title.clone(),
+            channel,
+            "button",
+            vec![format!("--note={}", note)],
+        )
+        .unwrap();
         // The choice of note here is arbitrary.
-        sig_shared(widget.channel().key_press(Note::default()))
+        sig_shared(widget.channel().key_press(note))
     })
 }
 

midi-udp-widgets-app-lib/src/knob.rs

@@ -26,9 +26,8 @@ fn new_knob_with_space(
     sensitivity: f32,
 ) -> KnobWithSpace {
     BY_TITLE.get_or_insert(title.as_str(), || {
-        let channel = midi::alloc_channel();
-        let controller = midi::alloc_controller(channel);
-        let space_controller = midi::alloc_controller(channel);
+        let (channel, controller) = midi::alloc_controller();
+        let (space_channel, space_controller) = midi::alloc_controller();
         let widget = Widget::new(
             title.clone(),
             channel,
@@ -37,6 +36,7 @@ fn new_knob_with_space(
                 format!("--controller={}", controller),
                 format!("--initial-value={}", initial_value_01),
                 format!("--sensitivity={}", sensitivity),
+                format!("--space-channel={}", space_channel),
                 format!("--space-controller={}", space_controller),
             ],
         )

midi-udp-widgets-app-lib/src/midi.rs

@@ -1,67 +1,276 @@
 use lazy_static::lazy_static;
 use midly::num::{u4, u7};
-use std::{collections::HashMap, sync::Mutex};
+use std::sync::Mutex;
 
-struct ChannelAllocator {
-    next_channel: Option<u4>,
-    next_controller_index_by_channel: HashMap<u4, Option<u7>>,
+pub type MidiChannel = u4;
+type MidiResource = u7;
+pub type MidiController = MidiResource;
+pub type MidiKey = MidiResource;
+
+#[derive(Debug)]
+struct AllMidiChannelsAreAlreadyAllocated;
+
+#[derive(Debug)]
+struct AllMidiResourcesAreAlreadyAllocated;
+
+struct GenericAllocator {
+    next: Option<u8>,
+    max: u8,
 }
 
-impl ChannelAllocator {
+impl GenericAllocator {
+    fn new(max: u8) -> Self {
+        Self { next: Some(0), max }
+    }
+
+    fn alloc(&mut self) -> Option<u8> {
+        self.next.map(|next| {
+            self.next = if next == self.max {
+                None
+            } else {
+                Some(next + 1)
+            };
+            next
+        })
+    }
+}
+
+struct MidiChannelAllocator(GenericAllocator);
+
+impl MidiChannelAllocator {
     fn new() -> Self {
+        Self(GenericAllocator::new(u4::max_value().into()))
+    }
+
+    fn alloc(
+        &mut self,
+    ) -> Result<MidiChannel, AllMidiChannelsAreAlreadyAllocated> {
+        match self.0.alloc() {
+            Some(value) => Ok(value.into()),
+            None => Err(AllMidiChannelsAreAlreadyAllocated),
+        }
+    }
+}
+
+/// Allocator for 7-bit midi resources such as controllers and keys
+struct MidiResourceAllocator(GenericAllocator);
+impl MidiResourceAllocator {
+    fn new() -> Self {
+        Self(GenericAllocator::new(u7::max_value().into()))
+    }
+
+    fn alloc(
+        &mut self,
+    ) -> Result<MidiResource, AllMidiResourcesAreAlreadyAllocated> {
+        match self.0.alloc() {
+            Some(value) => Ok(value.into()),
+            None => Err(AllMidiResourcesAreAlreadyAllocated),
+        }
+    }
+}
+
+impl Default for MidiResourceAllocator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum MidiResourceType {
+    Controller,
+    Key,
+}
+
+#[derive(Default)]
+struct MidiResourceTable<T> {
+    controller: T,
+    key: T,
+}
+
+impl<T> MidiResourceTable<T> {
+    fn get_mut(&mut self, type_: MidiResourceType) -> &mut T {
+        match type_ {
+            MidiResourceType::Controller => &mut self.controller,
+            MidiResourceType::Key => &mut self.key,
+        }
+    }
+
+    fn get(&self, type_: MidiResourceType) -> &T {
+        match type_ {
+            MidiResourceType::Controller => &self.controller,
+            MidiResourceType::Key => &self.key,
+        }
+    }
+}
+
+/// Allocates resources associated with a particular channel
+struct MidiResourceAllocators {
+    resource_table: MidiResourceTable<MidiResourceAllocator>,
+    channel: MidiChannel,
+}
+
+impl MidiResourceAllocators {
+    fn new(channel: MidiChannel) -> Self {
         Self {
-            next_channel: Some(0.into()),
-            next_controller_index_by_channel: HashMap::new(),
+            resource_table: Default::default(),
+            channel,
         }
     }
+}
 
-    fn alloc_channel(&mut self) -> u4 {
-        let channel = self.next_channel.expect("Can't allocate MIDI channel because all MIDI channels are in use already.");
-        self.next_channel = if channel == u4::max_value() {
-            None
-        } else {
-            Some((u8::from(channel) + 1).into())
+/// Allocates resources (controllers, keys) or entire channels. Resources are allocated from a pool
+/// of channels managed internally by this type.
+struct MidiAllocator {
+    channel_allocator: MidiChannelAllocator,
+    resource_allocators_pool: Vec<MidiResourceAllocators>,
+    resource_pool_indices: MidiResourceTable<usize>,
+}
+
+impl MidiAllocator {
+    fn new() -> Self {
+        let mut channel_allocator = MidiChannelAllocator::new();
+        let resource_allocator = {
+            let channel = channel_allocator
+                .alloc()
+                .expect("First allocation should always succeed.");
+            MidiResourceAllocators::new(channel)
         };
-        channel
+        Self {
+            channel_allocator,
+            resource_allocators_pool: vec![resource_allocator],
+            resource_pool_indices: MidiResourceTable {
+                controller: 0,
+                key: 0,
+            },
+        }
+    }
+
+    fn alloc_channel(
+        &mut self,
+    ) -> Result<MidiChannel, AllMidiChannelsAreAlreadyAllocated> {
+        self.channel_allocator.alloc()
     }
 
-    fn alloc_controller(&mut self, channel: u4) -> u7 {
-        if let Some(next_channel) = self.next_channel {
-            assert!(
-                channel < next_channel,
-                "Attempted to allocate controller on unallocated channel."
-            );
+    fn alloc_resource(
+        &mut self,
+        type_: MidiResourceType,
+    ) -> Result<(MidiChannel, MidiResource), AllMidiChannelsAreAlreadyAllocated>
+    {
+        if let Some(resource_allocators) = self
+            .resource_allocators_pool
+            .get_mut(*self.resource_pool_indices.get(type_))
+        {
+            match resource_allocators.resource_table.get_mut(type_).alloc() {
+                Ok(resource_index) => {
+                    Ok((resource_allocators.channel, resource_index))
+                }
+                Err(AllMidiResourcesAreAlreadyAllocated) => {
+                    let resource_pool_index =
+                        self.resource_pool_indices.get_mut(type_);
+                    *resource_pool_index += 1;
+                    let resource_allocators = if let Some(resource_allocators) =
+                        self.resource_allocators_pool
+                            .get_mut(*resource_pool_index)
+                    {
+                        resource_allocators
+                    } else {
+                        let channel = self.channel_allocator.alloc()?;
+                        self.resource_allocators_pool
+                            .push(MidiResourceAllocators::new(channel));
+                        assert_eq!(
+                            *resource_pool_index,
+                            self.resource_allocators_pool.len()
+                        );
+                        self.resource_allocators_pool.last_mut().unwrap()
+                    };
+                    let resource_index = resource_allocators
+                        .resource_table
+                        .get_mut(type_)
+                        .alloc()
+                        .expect("First allocation should always succeed.");
+                    Ok((resource_allocators.channel, resource_index))
+                }
+            }
+        } else {
+            panic!("Resource pool index should always be a valid index.");
         }
-        let next_controller = self
-            .next_controller_index_by_channel
-            .entry(channel)
-            .or_insert_with(|| Some(0.into()));
-        if let Some(controller) = *next_controller {
-            *next_controller = if controller == u7::max_value() {
-                None
-            } else {
-                Some((u8::from(controller) + 1).into())
-            };
-            controller
+    }
+
+    /// Allocate a pair of resources from the same channel. If the first resource would be the
+    /// final resource from its channel, it is leaked and a pair of resources are allocated from
+    /// the subsequent channel instead.
+    fn alloc_resource_2(
+        &mut self,
+        type_: MidiResourceType,
+    ) -> Result<
+        (MidiChannel, MidiResource, MidiResource),
+        AllMidiChannelsAreAlreadyAllocated,
+    > {
+        let r0 = self.alloc_resource(type_)?;
+        let r1 = self.alloc_resource(type_)?;
+        if r0.0 == r1.0 {
+            Ok((r0.0, r0.1, r1.1))
         } else {
-            panic!(
-                "Can't allocate MIDI controller because all MIDI controllers on channel {} are in use already.",
-                channel
-            );
+            let r2 = self.alloc_resource(type_)?;
+            assert_eq!(r1.0, r2.0);
+            Ok((r1.0, r1.1, r2.1))
         }
     }
+
+    fn alloc_controller(
+        &mut self,
+    ) -> Result<(MidiChannel, MidiController), AllMidiChannelsAreAlreadyAllocated>
+    {
+        self.alloc_resource(MidiResourceType::Controller)
+    }
+
+    fn alloc_controller_2(
+        &mut self,
+    ) -> Result<
+        (MidiChannel, MidiController, MidiController),
+        AllMidiChannelsAreAlreadyAllocated,
+    > {
+        self.alloc_resource_2(MidiResourceType::Controller)
+    }
+
+    fn alloc_key(
+        &mut self,
+    ) -> Result<(MidiChannel, MidiKey), AllMidiChannelsAreAlreadyAllocated>
+    {
+        self.alloc_resource(MidiResourceType::Key)
+    }
 }
 
 lazy_static! {
-    static ref CHANNEL_ALLOCATOR: Mutex<ChannelAllocator> =
-        Mutex::new(ChannelAllocator::new());
+    static ref ALLOCATOR: Mutex<MidiAllocator> =
+        Mutex::new(MidiAllocator::new());
+}
+
+pub fn alloc_channel() -> MidiChannel {
+    ALLOCATOR
+        .lock()
+        .unwrap()
+        .alloc_channel()
+        .expect("All MIDI channels are already allocated.")
+}
+
+pub fn alloc_controller() -> (MidiChannel, MidiController) {
+    ALLOCATOR.lock().unwrap().alloc_controller().expect(
+        "Allocating a new controller would require allocating a new channel, \
+        but all MIDI channels are already allocated.",
+    )
 }
 
-pub fn alloc_channel() -> u4 {
-    CHANNEL_ALLOCATOR.lock().unwrap().alloc_channel()
+pub fn alloc_controller_2() -> (MidiChannel, MidiController, MidiController) {
+    ALLOCATOR.lock().unwrap().alloc_controller_2().expect(
+        "Allocating a new controller would require allocating a new channel, \
+        but all MIDI channels are already allocated.",
+    )
 }
 
-pub fn alloc_controller(channel: u4) -> u7 {
-    let mut allocator = CHANNEL_ALLOCATOR.lock().unwrap();
-    allocator.alloc_controller(channel)
+pub fn alloc_key() -> (MidiChannel, MidiKey) {
+    ALLOCATOR.lock().unwrap().alloc_key().expect(
+        "Allocating a new controller would require allocating a new key, \
+        but all MIDI channels are already allocated.",
+    )
 }

midi-udp-widgets-app-lib/src/num_keys_bit_7.rs

@@ -22,15 +22,15 @@ lazy_static! {
 
 fn new_num_keys_bits_7_with_space(title: String) -> NumKeysBits7WithSpace {
     BY_TITLE.get_or_insert(title.as_str(), || {
-        let channel = midi::alloc_channel();
-        let controller = midi::alloc_controller(channel);
-        let space_controller = midi::alloc_controller(channel);
+        let (channel, controller) = midi::alloc_controller();
+        let (space_channel, space_controller) = midi::alloc_controller();
         let widget = Widget::new(
             title.clone(),
             channel,
             "num-keys-bits7",
             vec![
                 format!("--controller={}", controller),
+                format!("--space-channel={}", space_channel),
                 format!("--space-controller={}", space_controller),
             ],
         )