Add new standalone plugin format

- optional feature, disabled by default
- CPAL for audio IO, opening the default device with default settings
- midir for note input, opening the first available MIDI input device
- winit to create a slint host window

Author: emuell

examples/gain-plugin/Cargo.toml

@@ -3,6 +3,9 @@ name = "gain-plugin"
 version = "0.1.0"
 edition = "2024"
 
+[features]
+standalone = ["plinth-plugin/standalone"]
+
 [lib]
 crate-type = ["cdylib", "lib", "staticlib"]
 

examples/gain-plugin/src/lib.rs

@@ -3,3 +3,5 @@ mod parameters;
 mod plugin;
 mod processor;
 mod view;
+
+pub use plugin::GainPlugin;

plinth-plugin/Cargo.toml

@@ -8,6 +8,9 @@ readme = "README.md"
 repository = "https://github.com/ilmai/plugin-things"
 license = "MIT"
 
+[features]
+standalone = ["dep:cpal", "dep:midir", "dep:winit"]
+
 [dependencies]
 atomic_refcell = "0.1"
 clap-sys = "0.5"
@@ -22,6 +25,10 @@ thiserror = "2"
 vst3 = "0.3"
 widestring = "1"
 xxhash-rust = { version = "0.8", features = ["xxh32"] }
+# standalone features
+winit = { version = "0.30", optional = true }
+cpal = { version = "0.17", optional = true }
+midir = { version = "0.10", optional = true }
 
 [build-dependencies]
 bindgen = "0.72"

plinth-plugin/src/formats.rs

@@ -3,12 +3,16 @@ use std::fmt::Display;
 #[cfg(target_os="macos")]
 pub mod auv3;
 pub mod clap;
+#[cfg(feature = "standalone")]
+pub mod standalone;
 pub mod vst3;
 
 #[derive(Clone, Copy, Debug)]
 pub enum PluginFormat {
     Auv3,
     Clap,
+    #[cfg(feature = "standalone")]
+    Standalone,
     Vst3,
 }
 
@@ -17,6 +21,8 @@ impl Display for PluginFormat {
         match self {
             PluginFormat::Auv3 => f.write_str("AUv3"),
             PluginFormat::Clap => f.write_str("CLAP"),
+            #[cfg(feature = "standalone")]
+            PluginFormat::Standalone => f.write_str("Standalone"),
             PluginFormat::Vst3 => f.write_str("VST3"),
         }
     }

plinth-plugin/src/formats/standalone.rs

@@ -0,0 +1,10 @@
+mod audio;
+mod host;
+mod macros;
+mod midi;
+mod parameters;
+mod plugin;
+mod runner;
+
+pub use plugin::StandalonePlugin;
+pub use runner::run_standalone;

plinth-plugin/src/formats/standalone/audio.rs

@@ -0,0 +1,85 @@
+use std::sync::{Arc, mpsc::Receiver};
+
+use cpal::{FromSample, Sample};
+use plinth_core::{buffers::buffer::Buffer, signals::{signal::{Signal, SignalMut}, signal_base::SignalBase}};
+
+use super::parameters::StandaloneParameterEventMap;
+use super::plugin::StandalonePlugin;
+use crate::{Event, Processor};
+
+pub struct AudioState<P: StandalonePlugin> {
+    pub processor: P::Processor,
+    pub buffer: Buffer,
+    pub channels: usize,
+    pub midi_receiver: Receiver<Event>,
+    pub parameter_event_map: Arc<StandaloneParameterEventMap>,
+    pending_events: Vec<Event>,
+}
+
+impl<P: StandalonePlugin> AudioState<P> {
+    pub fn new(
+        processor: P::Processor,
+        channels: usize,
+        midi_receiver: Receiver<Event>,
+        parameter_event_map: Arc<StandaloneParameterEventMap>,
+    ) -> Self {
+        Self {
+            processor,
+            buffer: Buffer::new(channels, P::MAX_BLOCK_SIZE),
+            channels,
+            midi_receiver,
+            parameter_event_map,
+            pending_events: Vec::with_capacity(P::EVENT_QUEUE_LEN),
+        }
+    }
+
+    pub fn process<T>(&mut self, data: &mut [T], channels: usize)
+    where
+        T: Sample + FromSample<f32>,
+        f32: FromSample<T>,
+    {
+        let frame_count = data.len() / channels;
+
+        // Drain MIDI events
+        self.pending_events.clear();
+        while let Ok(event) = self.midi_receiver.try_recv() {
+            self.pending_events.push(event);
+        }
+        for event in self.parameter_event_map.iter_events() {
+            self.pending_events.push(event);
+        }
+
+        // Process audio, ensuring we don't call process with more than P::MAX_BLOCK_SIZE frames
+        let mut frame_offset = 0;
+        while frame_offset < frame_count {
+            let chunk_size = (frame_count - frame_offset).min(P::MAX_BLOCK_SIZE);
+
+            if self.buffer.len() != chunk_size {
+                self.buffer.resize(chunk_size);
+            }
+
+            // Deinterleave chunk from CPAL buffer
+            for frame in 0..chunk_size {
+                for ch in 0..self.channels {
+                    self.buffer.channel_mut(ch)[frame] =
+                        f32::from_sample(data[(frame_offset + frame) * self.channels + ch]);
+                }
+            }
+
+            // Process and drain all events on first run, assuming they have no time tags
+            let aux: Option<&Buffer> = None;
+            self.processor
+                .process(&mut self.buffer, aux, None, self.pending_events.drain(..));
+
+            // Reinterleave chunk back into CPAL buffer
+            for frame in 0..chunk_size {
+                for ch in 0..self.channels {
+                    data[(frame_offset + frame) * self.channels + ch] =
+                        T::from_sample(self.buffer.channel(ch)[frame]);
+                }
+            }
+
+            frame_offset += chunk_size;
+        }
+    }
+}

plinth-plugin/src/formats/standalone/host.rs

@@ -0,0 +1,54 @@
+use std::sync::{Arc, mpsc::Sender};
+
+use crate::{Event, Host, ParameterId, ParameterValue};
+
+use super::parameters::StandaloneParameterEventMap;
+
+pub struct StandaloneHost {
+    parameter_event_map: Arc<StandaloneParameterEventMap>,
+    to_plugin_sender: Sender<Event>,
+}
+
+impl StandaloneHost {
+    pub fn new(
+        parameter_event_map: Arc<StandaloneParameterEventMap>,
+        to_plugin_sender: Sender<Event>,
+    ) -> Self {
+        Self {
+            parameter_event_map,
+            to_plugin_sender,
+        }
+    }
+}
+
+impl Host for StandaloneHost {
+    fn can_resize(&self) -> bool {
+        false
+    }
+
+    fn resize_view(&self, _width: f64, _height: f64) -> bool {
+        false
+    }
+
+    fn start_parameter_change(&self, id: ParameterId) {
+        let _ = self.to_plugin_sender.send(Event::StartParameterChange { id });
+    }
+
+    fn change_parameter_value(&self, id: ParameterId, normalized: ParameterValue) {
+        self.parameter_event_map.change_parameter_value(id, normalized);
+
+        let _ = self.to_plugin_sender.send(Event::ParameterValue {
+            sample_offset: 0,
+            id,
+            value: normalized,
+        });
+    }
+
+    fn end_parameter_change(&self, id: ParameterId) {
+        let _ = self.to_plugin_sender.send(Event::EndParameterChange { id });
+    }
+
+    fn reload_parameters(&self) {}
+
+    fn mark_state_dirty(&self) {}
+}

plinth-plugin/src/formats/standalone/macros.rs

@@ -0,0 +1,8 @@
+#[macro_export]
+macro_rules! export_standalone {
+    ($plugin:ty) => {
+        fn main() {
+            ::plinth_plugin::standalone::run_standalone::<$plugin>();
+        }
+    };
+}

plinth-plugin/src/formats/standalone/midi.rs

@@ -0,0 +1,92 @@
+use std::sync::mpsc::Sender;
+
+use midir::{MidiInput, MidiInputConnection};
+
+use crate::Event;
+
+pub fn connect_midi_inputs(sender: Sender<Event>) -> Vec<MidiInputConnection<()>> {
+    let midi_in = match MidiInput::new("plinth-standalone") {
+        Ok(midi_in) => midi_in,
+        Err(err) => {
+            log::warn!("Failed to create MIDI input: {err}");
+            return vec![];
+        }
+    };
+
+    let ports = midi_in.ports();
+    let mut connections = Vec::with_capacity(ports.len());
+
+    for port in &ports {
+        let port_name = midi_in.port_name(port).unwrap_or_else(|_| port.id());
+        let midi_in = match MidiInput::new("plinth-standalone") {
+            Ok(m) => m,
+            Err(e) => {
+                log::warn!("Failed to create MIDI input for port '{port_name}': {e}");
+                continue;
+            }
+        };
+
+        let sender = sender.clone();
+        match midi_in.connect(
+            port,
+            "plinth-midi-input",
+            move |_timestamp, data, _| {
+                if let Some(event) = parse_midi(data) {
+                    let _ = sender.send(event);
+                }
+            },
+            (),
+        ) {
+            Ok(conn) => connections.push(conn),
+            Err(e) => log::warn!("Failed to connect to MIDI input port '{port_name}': {e}"),
+        }
+    }
+
+    connections
+}
+
+fn parse_midi(data: &[u8]) -> Option<Event> {
+    if data.len() < 2 {
+        return None;
+    }
+
+    let status = data[0] & 0xF0;
+    let channel = (data[0] & 0x0F) as i16;
+    let key = data[1] as i16;
+    let velocity = if data.len() >= 3 {
+        data[2] as f64 / 127.0
+    } else {
+        0.0
+    };
+
+    match status {
+        0x90 if data.len() >= 3 && data[2] > 0 => Some(Event::NoteOn {
+            sample_offset: 0,
+            channel,
+            key,
+            note: -1,
+            velocity,
+        }),
+        0x80 | 0x90 => Some(Event::NoteOff {
+            sample_offset: 0,
+            channel,
+            key,
+            note: -1,
+            velocity,
+        }),
+        0xE0 if data.len() >= 3 => {
+            let lsb = data[1] as i16;
+            let msb = data[2] as i16;
+            let bend = (msb << 7 | lsb) - 8192;
+            let semitones = bend as f64 / 8192.0 * 2.0;
+            Some(Event::PitchBend {
+                sample_offset: 0,
+                channel,
+                key: -1,
+                note: -1,
+                semitones,
+            })
+        }
+        _ => None,
+    }
+}

plinth-plugin/src/formats/standalone/parameters.rs

@@ -0,0 +1,62 @@
+use std::collections::{btree_map, BTreeMap};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use portable_atomic::AtomicF64;
+
+use crate::{Event, ParameterId, ParameterValue, Parameters};
+
+#[derive(Default)]
+struct ParameterEventInfo {
+    value: AtomicF64,
+    changed: AtomicBool,
+}
+
+pub(crate) struct StandaloneParameterEventMap {
+    parameter_event_info: BTreeMap<ParameterId, ParameterEventInfo>,
+}
+
+impl StandaloneParameterEventMap {
+    pub(crate) fn new(parameters: &impl Parameters) -> Self {
+        let mut parameter_event_info = BTreeMap::new();
+
+        for &id in parameters.ids() {
+            parameter_event_info.insert(id, Default::default());
+        }
+
+        Self { parameter_event_info }
+    }
+
+    pub(crate) fn change_parameter_value(&self, id: ParameterId, value: ParameterValue) {
+        let info = self.parameter_event_info.get(&id).unwrap();
+        info.value.store(value, Ordering::Release);
+        info.changed.store(true, Ordering::Release);
+    }
+
+    pub(crate) fn iter_events(&self) -> StandaloneParameterEventIterator<'_> {
+        StandaloneParameterEventIterator {
+            event_info_iterator: self.parameter_event_info.iter(),
+        }
+    }
+}
+
+pub(crate) struct StandaloneParameterEventIterator<'a> {
+    event_info_iterator: btree_map::Iter<'a, ParameterId, ParameterEventInfo>,
+}
+
+impl Iterator for StandaloneParameterEventIterator<'_> {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let (&id, info) = self.event_info_iterator.next()?;
+
+            if info.changed.swap(false, Ordering::AcqRel) {
+                return Some(Event::ParameterValue {
+                    sample_offset: 0,
+                    id,
+                    value: info.value.load(Ordering::Acquire),
+                });
+            }
+        }
+    }
+}