lv2-core 3.0.0

rust-lv2's core library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use std::os::raw::c_char;
use std::path::Path;
use std::str::Utf8Error;
use urid::Uri;

#[derive(Debug)]
pub enum PluginInfoError {
    InvalidBundlePathUtf8(Utf8Error),
}

/// Holds various data that is passed from the host at plugin instantiation time.
pub struct PluginInfo<'a> {
    plugin_uri: &'a Uri,
    bundle_path: &'a Path,
    sample_rate: f64,
}

impl<'a> PluginInfo<'a> {
    /// Create a new plugin info instance from raw information.
    ///
    /// # Safety
    ///
    /// This method is unsafe since it dereferences raw pointers. It panics when one of the pointers is null,
    /// but does not check the pointers for other validity.
    pub unsafe fn from_raw(
        plugin_descriptor: *const crate::sys::LV2_Descriptor,
        bundle_path: *const c_char,
        sample_rate: f64,
    ) -> Result<Self, PluginInfoError> {
        let bundle_path = Path::new(
            Uri::from_ptr(bundle_path)
                .to_str()
                .map_err(PluginInfoError::InvalidBundlePathUtf8)?,
        );
        Ok(Self::new(
            Uri::from_ptr((*plugin_descriptor).URI),
            bundle_path,
            sample_rate,
        ))
    }

    /// Create a new plugin info instance.
    pub fn new(plugin_uri: &'a Uri, bundle_path: &'a Path, sample_rate: f64) -> Self {
        Self {
            sample_rate,
            plugin_uri,
            bundle_path,
        }
    }

    /// The URI of the plugin that is being instantiated.
    pub fn plugin_uri(&self) -> &Uri {
        self.plugin_uri
    }

    /// The path to the LV2 bundle directory which contains this plugin binary.
    ///
    /// This is useful to get if the plugin needs to store extra resources in its bundle directory,
    /// such as presets, or any other kind of data.
    pub fn bundle_path(&self) -> &Path {
        self.bundle_path
    }

    /// The sample rate, in Hz, that is being used by the host.
    /// The host will always send audio data to the plugin at this sample rate.
    pub fn sample_rate(&self) -> f64 {
        self.sample_rate
    }
}