big ass refactor (rip client)

src/model/plugin.rs

@@ -0,0 +1,176 @@
+use crate::core::*;
+
+pub mod lv2;
+pub mod vst2;
+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 enum PluginKind {
+    LV2(LV2Plugin),
+    VST2 {
+        instance: ::vst::host::PluginInstance
+    },
+    VST3,
+}
+
+const HELM: &'static str = "file:///nix/store/ij3sz7nqg5l7v2dygdvzy3w6cj62bd6r-helm-0.9.0/lib/lv2/helm.lv2";
+
+impl Plugin {
+    /// Load a LV2 plugin.
+    pub fn lv2 (name: &str, path: &str) -> Usually<DynamicDevice<Self>> {
+        let host       = Self::new(name)?;
+        let plugin     = LV2Plugin::new(path)?;
+        let mut state  = host.state();
+        let client     = host.client.as_ref().unwrap().as_client();
+        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,
+        );
+        state.midi_ins = {
+            let mut ports = vec![];
+            for i in 0..midi_ins {
+                ports.push(client.register_port(&format!("midi-in-{i}"), MidiIn::default())?)
+            }
+            ports
+        };
+        state.midi_outs = {
+            let mut ports = vec![];
+            for i in 0..midi_outs {
+                ports.push(client.register_port(&format!("midi-out-{i}"), MidiOut::default())?)
+            }
+            ports
+        };
+        state.audio_ins = {
+            let mut ports = vec![];
+            for i in 0..audio_ins {
+                ports.push(client.register_port(&format!("audio-in-{i}"), AudioIn::default())?)
+            }
+            ports
+        };
+        state.audio_outs = {
+            let mut ports = vec![];
+            for i in 0..audio_outs {
+                ports.push(client.register_port(&format!("audio-out-{i}"), AudioOut::default())?)
+            }
+            ports
+        };
+        state.plugin = Some(PluginKind::LV2(plugin));
+        state.path   = Some(String::from(path));
+        std::mem::drop(state);
+        Ok(host)
+    }
+    pub fn new (name: &str) -> Usually<DynamicDevice<Self>> {
+        DynamicDevice::new(
+            crate::view::plugin::render,
+            crate::control::plugin::handle,
+            Self::process, 
+            Self {
+                name:       name.into(),
+                path:       None,
+                plugin:     None,
+                selected:   0,
+                mapping:    false,
+                midi_ins:   vec![],
+                midi_outs:  vec![],
+                audio_ins:  vec![],
+                audio_outs: vec![],
+            }
+        ).activate(Client::new(name, ClientOptions::NO_START_SERVER)?.0)
+    }
+    pub fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        match self.plugin.as_mut() {
+            Some(PluginKind::LV2(LV2Plugin { features, ref mut instance, .. })) => {
+                let urid = features.midi_urid();
+                let mut inputs = vec![];
+                for port in self.midi_ins.iter() {
+                    let mut atom = ::livi::event::LV2AtomSequence::new(
+                        &features,
+                        scope.n_frames() as usize
+                    );
+                    for event in port.iter(scope) {
+                        match event.bytes.len() {
+                            3 => atom.push_midi_event::<3>(
+                                event.time as i64,
+                                urid,
+                                &event.bytes[0..3]
+                            ).unwrap(),
+                            _ => {}
+                        }
+                    }
+                    inputs.push(atom);
+                }
+                let mut outputs = vec![];
+                for _ in self.midi_outs.iter() {
+                    outputs.push(::livi::event::LV2AtomSequence::new(
+                        &features,
+                        scope.n_frames() as usize
+                    ));
+                }
+                let ports = ::livi::EmptyPortConnections::new()
+                    .with_atom_sequence_inputs(
+                        inputs.iter()
+                    )
+                    .with_atom_sequence_outputs(
+                        outputs.iter_mut()
+                    )
+                    .with_audio_inputs(
+                        self.audio_ins.iter().map(|o|o.as_slice(scope))
+                    )
+                    .with_audio_outputs(
+                        self.audio_outs.iter_mut().map(|o|o.as_mut_slice(scope))
+                    );
+                unsafe {
+                    instance.run(scope.n_frames() as usize, ports).unwrap()
+                };
+            },
+            _ => {}
+        }
+        Control::Continue
+    }
+}
+
+impl PortList for Plugin {
+    fn audio_ins (&self) -> Usually<Vec<String>> {
+        let mut ports = vec![];
+        for port in self.audio_ins.iter() {
+            ports.push(port.name()?);
+        }
+        Ok(ports)
+    }
+    fn audio_outs (&self) -> Usually<Vec<String>> {
+        let mut ports = vec![];
+        for port in self.audio_outs.iter() {
+            ports.push(port.name()?);
+        }
+        Ok(ports)
+    }
+    fn midi_ins (&self) -> Usually<Vec<String>> {
+        let mut ports = vec![];
+        for port in self.midi_ins.iter() {
+            ports.push(port.name()?);
+        }
+        Ok(ports)
+    }
+    fn midi_outs (&self) -> Usually<Vec<String>> {
+        let mut ports = vec![];
+        for port in self.midi_outs.iter() {
+            ports.push(port.name()?);
+        }
+        Ok(ports)
+    }
+}