Struct PluginRef 

pub struct PluginRef {
    pub format: PluginFormat,
    pub path: PathBuf,
    pub plugin_id: Option<String>,
    pub name: String,
    pub vendor: String,
    pub version: String,
}

A specific plugin: bundle path plus the plugin id inside it.

Fields

format: PluginFormat

path: PathBuf

The .clap / .vst3 bundle (file or directory).

plugin_id: Option<String>

Plugin id inside the bundle (CLAP id or VST3 class id). None = the only one.

name: String

vendor: String

version: String

Implementations

impl PluginRef

pub fn from_path(path: impl Into<PathBuf>, plugin_id: Option<&str>) -> PluginRef

A plugin given directly by path (format from the extension, CLAP by default).

pub fn resolve(query: &str, sound_paths: &[PathBuf]) -> Result<PluginRef>

Resolve a name, id, or path ("Surge XT", org.surge-synth-team.surge-xt, plugin:"Surge XT", /path/Foo.clap, /path/Foo.clap#plugin.id) against the scan cache, the standard plugin folders, and sound_paths.

Examples found in repository

examples/render_note.rs (line 16)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    if args.len() < 2 {
        eprintln!("usage: render_note <plugin> <out.wav> [midi key] [param=value ...]");
        std::process::exit(2);
    }
    let plugin = PluginRef::resolve(&args[0], &[]).unwrap_or_else(|e| {
        eprintln!("{e}");
        std::process::exit(e.exit_code)
    });
    let key: u8 = args.get(2).and_then(|k| k.parse().ok()).unwrap_or(60);
    let params =
        args.iter().skip(3).filter_map(|kv| kv.split_once('=').map(|(k, v)| (k.to_string(), v.to_string()))).collect();
    let sr = 48000u32;
    let events = [MidiEvent::note_on(sr as u64 / 10, 0, key, 0.8), MidiEvent::note_off(sr as u64, 0, key)];
    let opts = PluginOptions { params, ..Default::default() };
    match render_instrument_with(&plugin, &events, sr, 2.0, &opts) {
        Ok(run) => {
            let a = &run.audio;
            let onset = a.data[0].iter().position(|v| v.abs() > 1e-4);
            println!(
                "{} ({}): {} frames, peak {:.3}, first sound at frame {:?} (note at {}), latency {}",
                plugin.name,
                plugin.format,
                a.frames(),
                a.peak(),
                onset,
                sr / 10,
                run.latency
            );
            std::fs::write(&args[1], ferraus_core::wav::encode(a, 32, true).expect("encode")).expect("write");
        }
        Err(e) => {
            eprintln!("{e}");
            std::process::exit(e.exit_code);
        }
    }
}

Trait Implementations

impl Clone for PluginRef

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PluginRef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PluginRef

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PluginRef

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for PluginRef

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PluginRef