extract plugin crate

plugin/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "tek_plugin"
+edition = "2021"
+version = "0.2.0"
+
+[dependencies]
+tek_tui  = { path = "../tui"  }
+tek_jack = { path = "../jack" }
+tek_time = { path = "../time" }
+tek_midi = { path = "../midi" }
+
+livi = "0.7.4"
+#once_cell = "1.19.0"
+#no_deadlocks = "1.3.2"
+#suil-rs = { path = "../suil" }
+#vst = "0.4.0"
+#vst3 = "0.1.0"
+#winit = { version = "0.30.4", features = [ "x11" ] }

plugin/src/lib.rs

@@ -0,0 +1,17 @@
+mod plugin; pub use self::plugin::*;
+mod lv2;    pub use self::lv2::*;
+
+pub(crate) use ::tek_jack::{*, jack::*};
+pub(crate) use ::tek_tui::{
+    *,
+    tek_output::*,
+    tek_input::*,
+    tek_edn::*,
+    ratatui::prelude::*,
+    crossterm::event::*,
+};
+
+pub(crate) use std::cmp::Ord;
+pub(crate) use std::fmt::{Debug, Formatter};
+pub(crate) use std::sync::{Arc, RwLock};
+pub(crate) use std::thread::JoinHandle;

plugin/src/lv2.rs

@@ -0,0 +1,40 @@
+use crate::*;
+
+/// A LV2 plugin.
+#[derive(Debug)]
+pub struct LV2Plugin {
+    pub world:        livi::World,
+    pub instance:     livi::Instance,
+    pub plugin:       livi::Plugin,
+    pub features:     Arc<livi::Features>,
+    pub port_list:    Vec<livi::Port>,
+    pub input_buffer: Vec<livi::event::LV2AtomSequence>,
+    pub ui_thread:    Option<JoinHandle<()>>,
+}
+
+impl LV2Plugin {
+    const INPUT_BUFFER: usize = 1024;
+    pub fn new (uri: &str) -> Usually<Self> {
+        let world = livi::World::with_load_bundle(&uri);
+        let features = world
+            .build_features(livi::FeaturesBuilder {
+                min_block_length: 1,
+                max_block_length: 65536,
+            });
+        let plugin = world.iter_plugins().nth(0)
+            .unwrap_or_else(||panic!("plugin not found: {uri}"));
+        Ok(Self {
+            instance: unsafe {
+                plugin
+                    .instantiate(features.clone(), 48000.0)
+                    .expect(&format!("instantiate failed: {uri}"))
+            },
+            port_list: plugin.ports().collect::<Vec<_>>(),
+            input_buffer: Vec::with_capacity(Self::INPUT_BUFFER),
+            ui_thread: None,
+            world,
+            features,
+            plugin,
+        })
+    }
+}

plugin/src/lv2_gui.rs

@@ -0,0 +1,59 @@
+use crate::*;
+use std::thread::{spawn, JoinHandle};
+use ::winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
+    window::{Window, WindowId},
+    platform::x11::EventLoopBuilderExtX11
+};
+
+//pub struct LV2PluginUI {
+    //write:      (),
+    //controller: (),
+    //widget:     (),
+    //features:   (),
+    //transfer:   (),
+//}
+
+pub fn run_lv2_ui (mut ui: LV2PluginUI) -> Usually<JoinHandle<()>> {
+    Ok(spawn(move||{
+        let event_loop = EventLoop::builder().with_x11().with_any_thread(true).build().unwrap();
+        event_loop.set_control_flow(ControlFlow::Wait);
+        event_loop.run_app(&mut ui).unwrap()
+    }))
+}
+
+/// A LV2 plugin's X11 UI.
+pub struct LV2PluginUI {
+    pub window: Option<Window>
+}
+
+impl LV2PluginUI {
+    pub fn new () -> Usually<Self> {
+        Ok(Self { window: None })
+    }
+}
+
+impl ApplicationHandler for LV2PluginUI {
+    fn resumed (&mut self, event_loop: &ActiveEventLoop) {
+        self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
+    }
+    fn window_event (&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
+        match event {
+            WindowEvent::CloseRequested => {
+                self.window.as_ref().unwrap().set_visible(false);
+                event_loop.exit();
+            },
+            WindowEvent::RedrawRequested => {
+                self.window.as_ref().unwrap().request_redraw();
+            }
+            _ => (),
+        }
+    }
+}
+
+fn lv2_ui_instantiate (kind: &str) {
+    //let host = Suil
+}
+

plugin/src/lv2_tui.rs

@@ -0,0 +1,47 @@
+
+use super::*;
+use ::livi::{
+    World,
+    Instance,
+    Plugin as LiviPlugin,
+    Features,
+    FeaturesBuilder,
+    Port,
+    event::LV2AtomSequence,
+};
+use std::thread::JoinHandle;
+
+/// A LV2 plugin.
+pub struct LV2Plugin {
+    pub world:        World,
+    pub instance:     Instance,
+    pub plugin:       LiviPlugin,
+    pub features:     Arc<Features>,
+    pub port_list:    Vec<Port>,
+    pub input_buffer: Vec<LV2AtomSequence>,
+    pub ui_thread:    Option<JoinHandle<()>>,
+}
+
+impl LV2Plugin {
+    const INPUT_BUFFER: usize = 1024;
+    pub fn new (uri: &str) -> Usually<Self> {
+        // Get 1st plugin at URI
+        let world    = World::with_load_bundle(&uri);
+        let features = FeaturesBuilder { min_block_length: 1, max_block_length: 65536 };
+        let features = world.build_features(features);
+        let mut plugin = None;
+        if let Some(p) = world.iter_plugins().next() { plugin = Some(p); }
+        let plugin   = plugin.expect("plugin not found");
+        let err      = &format!("init {uri}");
+        let instance = unsafe { plugin.instantiate(features.clone(), 48000.0).expect(&err) };
+        let mut port_list = vec![];
+        for port in plugin.ports() {
+            port_list.push(port);
+        }
+        let input_buffer = Vec::with_capacity(Self::INPUT_BUFFER);
+        // Instantiate
+        Ok(Self {
+            world, instance, port_list, plugin, features, input_buffer, ui_thread: None
+        })
+    }
+}

plugin/src/plugin.rs

@@ -0,0 +1,275 @@
+use crate::*;
+
+/// A plugin device.
+#[derive(Debug)]
+pub struct Plugin {
+    /// JACK client handle (needs to not be dropped for standalone mode to work).
+    pub jack:       Arc<RwLock<JackConnection>>,
+    pub name:       Arc<str>,
+    pub path:       Option<Arc<str>>,
+    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>>,
+}
+
+/// Supported plugin formats.
+#[derive(Default)]
+pub enum PluginKind {
+    #[default] None,
+    LV2(LV2Plugin),
+    VST2 { instance: () /*::vst::host::PluginInstance*/ },
+    VST3,
+}
+
+impl Debug for PluginKind {
+    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        write!(f, "{}", match self {
+            Self::None     => "(none)",
+            Self::LV2(_)   => "LV2",
+            Self::VST2{..} => "VST2",
+            Self::VST3     => "VST3",
+        })
+    }
+}
+impl Plugin {
+    pub fn new_lv2 (
+        jack: &Arc<RwLock<JackConnection>>,
+        name: &str,
+        path: &str,
+    ) -> Usually<Self> {
+        Ok(Self {
+            jack:       jack.clone(),
+            name:       name.into(),
+            path:       Some(String::from(path).into()),
+            plugin:     Some(PluginKind::LV2(LV2Plugin::new(path)?)),
+            selected:   0,
+            mapping:    false,
+            midi_ins:   vec![],
+            midi_outs:  vec![],
+            audio_ins:  vec![],
+            audio_outs: vec![],
+        })
+    }
+}
+
+pub struct PluginAudio(Arc<RwLock<Plugin>>);
+from!(|model: &Arc<RwLock<Plugin>>| PluginAudio = Self(model.clone()));
+audio!(|self: PluginAudio, client, scope|{
+    let state = &mut*self.0.write().unwrap();
+    match state.plugin.as_mut() {
+        Some(PluginKind::LV2(LV2Plugin {
+            features,
+            ref mut instance,
+            ref mut input_buffer,
+            ..
+        })) => {
+            let urid = features.midi_urid();
+            input_buffer.clear();
+            for port in state.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(),
+                        _ => {}
+                    }
+                }
+                input_buffer.push(atom);
+            }
+            let mut outputs = vec![];
+            for _ in state.midi_outs.iter() {
+                outputs.push(::livi::event::LV2AtomSequence::new(
+                    features,
+                    scope.n_frames() as usize
+                ));
+            }
+            let ports = ::livi::EmptyPortConnections::new()
+                .with_atom_sequence_inputs(input_buffer.iter())
+                .with_atom_sequence_outputs(outputs.iter_mut())
+                .with_audio_inputs(state.audio_ins.iter().map(|o|o.as_slice(scope)))
+                .with_audio_outputs(state.audio_outs.iter_mut().map(|o|o.as_mut_slice(scope)));
+            unsafe {
+                instance.run(scope.n_frames() as usize, ports).unwrap()
+            };
+        },
+        _ => todo!("only lv2 is supported")
+    }
+    Control::Continue
+});
+
+    //fn jack_from_lv2 (name: &str, plugin: &::livi::Plugin) -> Usually<Jack> {
+        //let counts = plugin.port_counts();
+        //let mut jack = Jack::new(name)?;
+        //for i in 0..counts.atom_sequence_inputs {
+            //jack = jack.midi_in(&format!("midi-in-{i}"))
+        //}
+        //for i in 0..counts.atom_sequence_outputs {
+            //jack = jack.midi_out(&format!("midi-out-{i}"));
+        //}
+        //for i in 0..counts.audio_inputs {
+            //jack = jack.audio_in(&format!("audio-in-{i}"));
+        //}
+        //for i in 0..counts.audio_outputs {
+            //jack = jack.audio_out(&format!("audio-out-{i}"));
+        //}
+        //Ok(jack)
+    //}
+
+impl Plugin {
+    /// Create a plugin host device.
+    pub fn new (
+        jack: &Arc<RwLock<JackConnection>>,
+        name: &str,
+    ) -> Usually<Self> {
+        Ok(Self {
+            //_engine:    Default::default(),
+            jack:       jack.clone(),
+            name:       name.into(),
+            path:       None,
+            plugin:     None,
+            selected:   0,
+            mapping:    false,
+            audio_ins:  vec![],
+            audio_outs: vec![],
+            midi_ins:   vec![],
+            midi_outs:  vec![],
+            //ports:      JackPorts::default()
+        })
+    }
+}
+impl Content<TuiOut> for Plugin {
+    fn render (&self, to: &mut TuiOut) {
+        let area = to.area();
+        let [x, y, _, height] = area;
+        let mut width = 20u16;
+        match &self.plugin {
+            Some(PluginKind::LV2(LV2Plugin { port_list, instance, .. })) => {
+                let start = self.selected.saturating_sub((height as usize / 2).saturating_sub(1));
+                let end   = start + height as usize - 2;
+                //draw_box(buf, Rect { x, y, width, height });
+                for i in start..end {
+                    if let Some(port) = port_list.get(i) {
+                        let value = if let Some(value) = instance.control_input(port.index) {
+                            value
+                        } else {
+                            port.default_value
+                        };
+                        //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
+                        let label = &format!("{:25} = {value:.03}", port.name);
+                        width = width.max(label.len() as u16 + 4);
+                        let style = if i == self.selected {
+                            Some(Style::default().green())
+                        } else {
+                            None
+                        } ;
+                        to.blit(&label, x + 2, y + 1 + i as u16 - start as u16, style);
+                    } else {
+                        break
+                    }
+                }
+            },
+            _ => {}
+        };
+        draw_header(self, to, x, y, width);
+    }
+}
+
+fn draw_header (state: &Plugin, to: &mut TuiOut, x: u16, y: u16, w: u16) {
+    let style  = Style::default().gray();
+    let label1 = format!(" {}", state.name);
+    to.blit(&label1, x + 1, y, Some(style.white().bold()));
+    if let Some(ref path) = state.path {
+        let label2 = format!("{}…", &path[..((w as usize - 10).min(path.len()))]);
+        to.blit(&label2, x + 2 + label1.len() as u16, y, Some(style.not_dim()));
+    }
+    //Ok(Rect { x, y, width: w, height: 1 })
+}
+
+handle!(TuiIn: |self:Plugin, from|{
+    match from.event() {
+        kpat!(KeyCode::Up) => {
+            self.selected = self.selected.saturating_sub(1);
+            Ok(Some(true))
+        },
+        kpat!(KeyCode::Down) => {
+            self.selected = (self.selected + 1).min(match &self.plugin {
+                Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+                _ => unimplemented!()
+            });
+            Ok(Some(true))
+        },
+        kpat!(KeyCode::PageUp) => {
+            self.selected = self.selected.saturating_sub(8);
+            Ok(Some(true))
+        },
+        kpat!(KeyCode::PageDown) => {
+            self.selected = (self.selected + 10).min(match &self.plugin {
+                Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+                _ => unimplemented!()
+            });
+            Ok(Some(true))
+        },
+        kpat!(KeyCode::Char(',')) => {
+            match self.plugin.as_mut() {
+                Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                    let index = port_list[self.selected].index;
+                    if let Some(value) = instance.control_input(index) {
+                        instance.set_control_input(index, value - 0.01);
+                    }
+                },
+                _ => {}
+            }
+            Ok(Some(true))
+        },
+        kpat!(KeyCode::Char('.')) => {
+            match self.plugin.as_mut() {
+                Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                    let index = port_list[self.selected].index;
+                    if let Some(value) = instance.control_input(index) {
+                        instance.set_control_input(index, value + 0.01);
+                    }
+                },
+                _ => {}
+            }
+            Ok(Some(true))
+        },
+        kpat!(KeyCode::Char('g')) => {
+            match self.plugin {
+                //Some(PluginKind::LV2(ref mut plugin)) => {
+                    //plugin.ui_thread = Some(run_lv2_ui(LV2PluginUI::new()?)?);
+                //},
+                Some(_) => unreachable!(),
+                None => {}
+            }
+            Ok(Some(true))
+        },
+        _ => Ok(None)
+    }
+});
+
+from_edn!("plugin/lv2" => |jack: &Arc<RwLock<JackConnection>>, args| -> Plugin {
+    let mut name = String::new();
+    let mut path = String::new();
+    edn!(edn in args {
+        Edn::Map(map) => {
+            if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
+                name = String::from(*n);
+            }
+            if let Some(Edn::Str(p)) = map.get(&Edn::Key(":path")) {
+                path = String::from(*p);
+            }
+        },
+        _ => panic!("unexpected in lv2 '{name}'"),
+    });
+    Plugin::new_lv2(jack, &name, &path)
+});

plugin/src/vst2_tui.rs

@@ -0,0 +1,14 @@
+use crate::*;
+
+impl<E: Engine> ::vst::host::Host for Plugin<E> {}
+
+fn set_vst_plugin <E: Engine> (host: &Arc<Mutex<Plugin<E>>>, _path: &str) -> Usually<PluginKind> {
+    let mut loader = ::vst::host::PluginLoader::load(
+        &std::path::Path::new("/nix/store/ij3sz7nqg5l7v2dygdvzy3w6cj62bd6r-helm-0.9.0/lib/lxvst/helm.so"),
+        host.clone()
+    )?;
+    Ok(PluginKind::VST2 {
+        instance: loader.instance()?
+    })
+}
+

plugin/src/vst3_tui.rs

@@ -0,0 +1,2 @@
+//! TODO
+