wip: connect devices

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);