wip: connect devices

src/model/plugin.rs

@@ -7,28 +7,24 @@ pub mod vst3;
 use self::lv2::*;
 
 pub struct Plugin {
-    pub name:       String,
-    pub path:       Option<String>,
-    pub plugin:     Option<PluginKind>,
-    pub selected:   usize,
-    pub mapping:    bool,
-    pub midi_ins:   Vec<Port<MidiIn>>,
-    pub midi_outs:  Vec<Port<MidiOut>>,
-    pub audio_ins:  Vec<Port<AudioIn>>,
-    pub audio_outs: Vec<Port<AudioOut>>,
-    pub jack:       Client,
+    pub name:     String,
+    pub path:     Option<String>,
+    pub plugin:   Option<PluginKind>,
+    pub selected: usize,
+    pub mapping:  bool,
+    pub ports:    JackPorts,
 }
 render!(Plugin = crate::view::plugin::render);
 handle!(Plugin = crate::control::plugin::handle);
 process!(Plugin = Plugin::process);
 ports!(Plugin {
     audio: {
-        ins:  |track|Ok(track.audio_ins.iter().collect()),
-        outs: |track|Ok(track.audio_outs.iter().collect()),
+        ins:  |p|Ok(p.ports.audio_ins.values().collect()),
+        outs: |p|Ok(p.ports.audio_outs.values().collect()),
     }
     midi: {
-        ins:  |track|Ok(track.midi_ins.iter().collect()),
-        outs: |track|Ok(track.midi_outs.iter().collect()),
+        ins:  |p|Ok(p.ports.midi_ins.values().collect()),
+        outs: |p|Ok(p.ports.midi_outs.values().collect()),
     }
 });
 
@@ -41,20 +37,15 @@ pub enum PluginKind {
 }
 
 impl Plugin {
-    /// Load a LV2 plugin.
+    /// Create a plugin host device.
     pub fn new (name: &str) -> Usually<Self> {
-        let (jack, _) = Client::new(name, ClientOptions::NO_START_SERVER)?;
         Ok(Self {
             name:       name.into(),
             path:       None,
             plugin:     None,
             selected:   0,
             mapping:    false,
-            midi_ins:   vec![],
-            midi_outs:  vec![],
-            audio_ins:  vec![],
-            audio_outs: vec![],
-            jack,
+            ports:      JackPorts::default()
         })
     }
     pub fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
@@ -62,7 +53,7 @@ impl Plugin {
             Some(PluginKind::LV2(LV2Plugin { features, ref mut instance, .. })) => {
                 let urid = features.midi_urid();
                 let mut inputs = vec![];
-                for port in self.midi_ins.iter() {
+                for port in self.ports.midi_ins.values() {
                     let mut atom = ::livi::event::LV2AtomSequence::new(
                         &features,
                         scope.n_frames() as usize
@@ -80,7 +71,7 @@ impl Plugin {
                     inputs.push(atom);
                 }
                 let mut outputs = vec![];
-                for _ in self.midi_outs.iter() {
+                for _ in self.ports.midi_outs.iter() {
                     outputs.push(::livi::event::LV2AtomSequence::new(
                         &features,
                         scope.n_frames() as usize
@@ -94,10 +85,10 @@ impl Plugin {
                         outputs.iter_mut()
                     )
                     .with_audio_inputs(
-                        self.audio_ins.iter().map(|o|o.as_slice(scope))
+                        self.ports.audio_ins.values().map(|o|o.as_slice(scope))
                     )
                     .with_audio_outputs(
-                        self.audio_outs.iter_mut().map(|o|o.as_mut_slice(scope))
+                        self.ports.audio_outs.values_mut().map(|o|o.as_mut_slice(scope))
                     );
                 unsafe {
                     instance.run(scope.n_frames() as usize, ports).unwrap()

src/model/plugin/lv2.rs

@@ -41,46 +41,17 @@ impl LV2Plugin {
 }
 
 impl super::Plugin {
-    pub fn lv2 (name: &str, path: &str) -> Usually<Self> {
-        let mut host = Self::new(name)?;
+    pub fn lv2 (name: &str, path: &str) -> Usually<Arc<Mutex<Box<dyn Device>>>> {
         let plugin = LV2Plugin::new(path)?;
-        let client = &host.jack;
-        let (midi_ins, midi_outs, audio_ins, audio_outs) = (
-            plugin.plugin.port_counts().atom_sequence_inputs,
-            plugin.plugin.port_counts().atom_sequence_outputs,
-            plugin.plugin.port_counts().audio_inputs,
-            plugin.plugin.port_counts().audio_outputs,
-        );
-        host.midi_ins = {
-            let mut ports = vec![];
-            for i in 0..midi_ins {
-                ports.push(client.register_port(&format!("midi-in-{i}"), MidiIn::default())?)
-            }
-            ports
-        };
-        host.midi_outs = {
-            let mut ports = vec![];
-            for i in 0..midi_outs {
-                ports.push(client.register_port(&format!("midi-out-{i}"), MidiOut::default())?)
-            }
-            ports
-        };
-        host.audio_ins = {
-            let mut ports = vec![];
-            for i in 0..audio_ins {
-                ports.push(client.register_port(&format!("audio-in-{i}"), AudioIn::default())?)
-            }
-            ports
-        };
-        host.audio_outs = {
-            let mut ports = vec![];
-            for i in 0..audio_outs {
-                ports.push(client.register_port(&format!("audio-out-{i}"), AudioOut::default())?)
-            }
-            ports
-        };
-        host.plugin = Some(super::PluginKind::LV2(plugin));
-        host.path   = Some(String::from(path));
-        Ok(host)
+        Jack::new(name)?
+            .ports_from_lv2(&plugin.plugin)?
+            .run(|ports|Box::new(Self {
+                name:       name.into(),
+                path:       Some(String::from(path)),
+                plugin:     Some(super::PluginKind::LV2(plugin)),
+                selected:   0,
+                mapping:    false,
+                ports
+            }))
     }
 }

src/model/sampler.rs

@@ -13,17 +13,6 @@ pub struct Sample {
     pub channels: Vec<Vec<f32>>,
 }
 
-pub struct Sampler {
-    pub name:       String,
-    pub jack:       Client,
-    pub cursor:     (usize, usize),
-    pub samples:    BTreeMap<u7, Arc<Sample>>,
-    pub voices:     Vec<Voice>,
-    pub midi_in:    Port<MidiIn>,
-    pub audio_ins:  Vec<Port<AudioIn>>,
-    pub audio_outs: Vec<Port<AudioOut>>,
-}
-
 impl Voice {
     pub fn chunk (&mut self, mut frames: usize) -> Option<Vec<Vec<f32>>> {
         // Create output buffer for each channel
@@ -62,46 +51,65 @@ impl Sample {
         Voice { sample: self.clone(), after, position: self.start }
     }
 }
+
+pub struct Sampler {
+    pub name:    String,
+    pub cursor:  (usize, usize),
+    pub samples: BTreeMap<u7, Arc<Sample>>,
+    pub voices:  Vec<Voice>,
+    pub ports:   JackPorts,
+}
+
 render!(Sampler = crate::view::sampler::render);
 handle!(Sampler = crate::control::sampler::handle);
+//jack!(Sampler {
+    //process = Sampler::process,
+    //audio = {
+        //ins  = |s|Ok(s.jack.audio_ins.values().collect()),
+        //outs = |s|Ok(s.jack.audio_outs.values().collect()),
+    //}
+    //midi = {
+        //ins  = |s|Ok(s.jack.midi_ins.values().collect()),
+        //outs = |s|Ok(s.jack.midi_outs.values().collect()),
+    //}
+//});
 process!(Sampler = Sampler::process);
 ports!(Sampler {
     audio: {
-        ins:  |s|Ok(s.audio_ins.iter().collect()),
-        outs: |s|Ok(s.audio_outs.iter().collect()),
+        ins:  |s|Ok(s.ports.audio_ins.values().collect()),
+        outs: |s|Ok(s.ports.audio_outs.values().collect()),
+    }
+    midi: {
+        ins:  |s|Ok(s.ports.midi_ins.values().collect()),
+        outs: |s|Ok(s.ports.midi_outs.values().collect()),
     }
-    midi: { ins: |s|Ok(vec![&s.midi_in]), }
 });
 
 impl Sampler {
     pub fn new (
         name: &str, samples: Option<BTreeMap<u7, Arc<Sample>>>,
-    ) -> Usually<Self> {
-        let (jack, _) = Client::new(name, ClientOptions::NO_START_SERVER)?;
-        Ok(Self {
-            name: name.into(),
-            cursor: (0, 0),
-            samples: samples.unwrap_or(BTreeMap::new()),
-            voices: vec![],
-            midi_in: jack.register_port("midi", MidiIn::default())?,
-            audio_ins: vec![
-                jack.register_port("recL", AudioIn::default())?,
-                jack.register_port("recR", AudioIn::default())?,
-            ],
-            audio_outs: vec![
-                jack.register_port("outL", AudioOut::default())?,
-                jack.register_port("outR", AudioOut::default())?,
-            ],
-            jack
-        })
+    ) -> Usually<Arc<Mutex<Box<dyn Device>>>> {
+        Jack::new(name)?
+            .register_midi_in("midi")?
+            .register_audio_in("recL")?
+            .register_audio_in("recR")?
+            .register_audio_out("outL")?
+            .register_audio_out("outR")?
+            .run(|ports|Box::new(Self {
+                name:    name.into(),
+                cursor:  (0, 0),
+                samples: samples.unwrap_or(BTreeMap::new()),
+                voices:  vec![],
+                ports
+            }))
     }
 
     pub fn process (&mut self, _: &Client, scope:  &ProcessScope) -> Control {
         // Output buffer: this will be copied to the audio outs.
-        let channel_count = self.audio_outs.len();
+        let channel_count = self.ports.audio_outs.len();
         let mut mixed = vec![vec![0.0;scope.n_frames() as usize];channel_count];
         // Process MIDI input to add new voices.
-        for RawMidi { time, bytes } in self.midi_in.iter(scope) {
+        for RawMidi { time, bytes } in self.ports.midi_ins.get("midi").unwrap().iter(scope) {
             if let LiveEvent::Midi { message, .. } = LiveEvent::parse(bytes).unwrap() {
                 if let MidiMessage::NoteOn { ref key, .. } = message {
                     if let Some(sample) = self.samples.get(key) {
@@ -130,7 +138,7 @@ impl Sampler {
             }
         }
         // Write output buffer to output ports.
-        for (i, port) in self.audio_outs.iter_mut().enumerate() {
+        for (i, port) in self.ports.audio_outs.values_mut().enumerate() {
             let buffer = &mixed[i];
             for (i, value) in port.as_mut_slice(scope).iter_mut().enumerate() {
                 *value = *buffer.get(i).unwrap_or(&0.0);

src/model/track.rs

@@ -18,7 +18,7 @@ pub struct Track {
     /// Red keys on piano roll.
     pub notes_on:   Vec<bool>,
     /// Device chain
-    pub devices:    Vec<Box<dyn Device>>,
+    pub devices:    Vec<Arc<Mutex<Box<dyn Device>>>>,
     /// Device selector
     pub device:     usize,
 }
@@ -27,8 +27,8 @@ impl Track {
     pub fn new (
         name:    &str,
         jack:    &Client,
-        devices: Option<Vec<Box<dyn Device>>>,
         phrases: Option<Vec<Phrase>>,
+        devices: Option<Vec<Arc<Mutex<Box<dyn Device>>>>>,
     ) -> Usually<Self> {
         Ok(Self {
             name:       name.to_string(),
@@ -43,17 +43,17 @@ impl Track {
             device:     0,
         })
     }
-    pub fn device (&self) -> Option<&Box<dyn Device>> {
-        self.devices.get(self.device)
+    pub fn device (&self, i: usize) -> Option<MutexGuard<Box<dyn Device>>> {
+        self.devices.get(i).map(|d|d.lock().unwrap())
     }
-    pub fn device_mut (&mut self) -> Option<&mut Box<dyn Device>> {
-        self.devices.get_mut(self.device)
+    pub fn active_device (&self) -> Option<MutexGuard<Box<dyn Device>>> {
+        self.device(self.device)
     }
-    pub fn first_device (&self) -> Option<&Box<dyn Device>> {
-        self.devices.get(0)
+    pub fn first_device (&self) -> Option<MutexGuard<Box<dyn Device>>> {
+        self.device(0)
     }
-    pub fn last_device (&self) -> Option<&Box<dyn Device>> {
-        self.devices.get(self.devices.len().saturating_sub(1))
+    pub fn last_device (&self) -> Option<MutexGuard<Box<dyn Device>>> {
+        self.device(self.devices.len().saturating_sub(1))
     }
     pub fn phrase (&self) -> Option<&Phrase> {
         if let Some(phrase) = self.sequence {