mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 11:46:41 +01:00
310 lines
10 KiB
Rust
310 lines
10 KiB
Rust
use crate::*;
|
|
|
|
/// A LV2 plugin.
|
|
#[derive(Debug)]
|
|
pub struct Lv2 {
|
|
/// JACK client handle (needs to not be dropped for standalone mode to work).
|
|
pub jack: Jack<'static>,
|
|
pub name: Arc<str>,
|
|
pub path: Option<Arc<str>>,
|
|
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 lv2_world: livi::World,
|
|
pub lv2_instance: livi::Instance,
|
|
pub lv2_plugin: livi::Plugin,
|
|
pub lv2_features: Arc<livi::Features>,
|
|
pub lv2_port_list: Vec<livi::Port>,
|
|
pub lv2_input_buffer: Vec<livi::event::LV2AtomSequence>,
|
|
pub lv2_ui_thread: Option<JoinHandle<()>>,
|
|
}
|
|
|
|
impl Lv2 {
|
|
|
|
pub fn new (
|
|
jack: &Jack<'static>,
|
|
name: &str,
|
|
uri: &str,
|
|
) -> Usually<Self> {
|
|
let lv2_world = livi::World::with_load_bundle(&uri);
|
|
let lv2_features = lv2_world.build_features(livi::FeaturesBuilder {
|
|
min_block_length: 1,
|
|
max_block_length: 65536,
|
|
});
|
|
let lv2_plugin = lv2_world.iter_plugins().nth(0)
|
|
.unwrap_or_else(||panic!("plugin not found: {uri}"));
|
|
Ok(Self {
|
|
jack: jack.clone(),
|
|
name: name.into(),
|
|
path: Some(String::from(uri).into()),
|
|
selected: 0,
|
|
mapping: false,
|
|
midi_ins: vec![],
|
|
midi_outs: vec![],
|
|
audio_ins: vec![],
|
|
audio_outs: vec![],
|
|
lv2_instance: unsafe {
|
|
lv2_plugin
|
|
.instantiate(lv2_features.clone(), 48000.0)
|
|
.expect(&format!("instantiate failed: {uri}"))
|
|
},
|
|
lv2_port_list: lv2_plugin.ports().collect::<Vec<_>>(),
|
|
lv2_input_buffer: Vec::with_capacity(Self::INPUT_BUFFER),
|
|
lv2_ui_thread: None,
|
|
lv2_world,
|
|
lv2_features,
|
|
lv2_plugin,
|
|
})
|
|
}
|
|
|
|
const INPUT_BUFFER: usize = 1024;
|
|
|
|
}
|
|
|
|
|
|
//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)
|
|
//}
|
|
|
|
audio!(|self: Lv2, _client, scope|{
|
|
let Self {
|
|
midi_ins,
|
|
midi_outs,
|
|
audio_ins,
|
|
audio_outs,
|
|
lv2_features,
|
|
lv2_instance,
|
|
lv2_input_buffer,
|
|
..
|
|
} = self;
|
|
let urid = lv2_features.midi_urid();
|
|
lv2_input_buffer.clear();
|
|
for port in midi_ins.iter() {
|
|
let mut atom = ::livi::event::LV2AtomSequence::new(
|
|
&lv2_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(),
|
|
_ => {}
|
|
}
|
|
}
|
|
lv2_input_buffer.push(atom);
|
|
}
|
|
let mut outputs = vec![];
|
|
for _ in midi_outs.iter() {
|
|
outputs.push(::livi::event::LV2AtomSequence::new(
|
|
lv2_features,
|
|
scope.n_frames() as usize
|
|
));
|
|
}
|
|
let ports = ::livi::EmptyPortConnections::new()
|
|
.with_atom_sequence_inputs(lv2_input_buffer.iter())
|
|
.with_atom_sequence_outputs(outputs.iter_mut())
|
|
.with_audio_inputs(audio_ins.iter().map(|o|o.as_slice(scope)))
|
|
.with_audio_outputs(audio_outs.iter_mut().map(|o|o.as_mut_slice(scope)));
|
|
unsafe {
|
|
lv2_instance.run(scope.n_frames() as usize, ports).unwrap()
|
|
};
|
|
Control::Continue
|
|
});
|
|
|
|
impl Draw<TuiOut> for Lv2 {
|
|
fn draw (&self, to: &mut TuiOut) {
|
|
let area = to.area();
|
|
let [x, y, _, height] = area;
|
|
let mut width = 20u16;
|
|
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) = self.lv2_port_list.get(i) {
|
|
let value = if let Some(value) = self.lv2_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: &Lv2, 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_atom!("plugin/lv2" => |jack: &Jack, args| -> Plugin {
|
|
//let mut name = String::new();
|
|
//let mut path = String::new();
|
|
//atom!(atom in args {
|
|
//Atom::Map(map) => {
|
|
//if let Some(Atom::Str(n)) = map.get(&Atom::Key(":name")) {
|
|
//name = String::from(*n);
|
|
//}
|
|
//if let Some(Atom::Str(p)) = map.get(&Atom::Key(":path")) {
|
|
//path = String::from(*p);
|
|
//}
|
|
//},
|
|
//_ => panic!("unexpected in lv2 '{name}'"),
|
|
//});
|
|
//Plugin::new_lv2(jack, &name, &path)
|
|
//});
|
|
|
|
//pub struct LV2PluginUI {
|
|
//write: (),
|
|
//controller: (),
|
|
//widget: (),
|
|
//features: (),
|
|
//transfer: (),
|
|
//}
|
|
|
|
|
|
#[cfg(feature = "lv2_gui")]
|
|
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()
|
|
}))
|
|
}
|
|
|
|
#[cfg(feature = "lv2_gui")]
|
|
/// A LV2 plugin's X11 UI.
|
|
pub struct LV2PluginUI {
|
|
pub window: Option<Window>
|
|
}
|
|
|
|
#[cfg(feature = "lv2_gui")]
|
|
impl LV2PluginUI {
|
|
pub fn new () -> Usually<Self> {
|
|
Ok(Self { window: None })
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "lv2_gui")]
|
|
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();
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "lv2_gui")]
|
|
fn lv2_ui_instantiate (kind: &str) {
|
|
//let host = Suil
|
|
}
|