rack 0.4.8

A modern Rust library for hosting audio plugins
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::path::PathBuf;

/// Information about a discovered audio plugin
#[derive(Debug, Clone)]
pub struct PluginInfo {
    /// Plugin name (e.g., "AUGraphicEQ")
    pub name: String,

    /// Manufacturer/vendor name (e.g., "Apple")
    pub manufacturer: String,

    /// Plugin version
    pub version: u32,

    /// Plugin type (effect, instrument, etc.)
    pub plugin_type: PluginType,

    /// Path to the plugin bundle (for AudioUnits, this is the .component path)
    pub path: PathBuf,

    /// Unique identifier for the plugin
    pub unique_id: String,
}

/// Type of audio plugin
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PluginType {
    /// Audio effect (processes audio input to output)
    Effect,

    /// Instrument/generator (generates audio from MIDI/events)
    Instrument,

    /// Mixer
    Mixer,

    /// Format converter
    FormatConverter,

    /// Analyzer (spectral/metering plugins)
    Analyzer,

    /// Spatial audio processor (surround, binaural, etc.)
    Spatial,

    /// Other/unknown type
    Other,
}

impl PluginInfo {
    /// Create a new PluginInfo
    pub fn new(
        name: String,
        manufacturer: String,
        version: u32,
        plugin_type: PluginType,
        path: PathBuf,
        unique_id: String,
    ) -> Self {
        Self {
            name,
            manufacturer,
            version,
            plugin_type,
            path,
            unique_id,
        }
    }
}

impl std::fmt::Display for PluginInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{} by {} (v{}) [{:?}]",
            self.name, self.manufacturer, self.version, self.plugin_type
        )
    }
}

/// Information about a plugin parameter
#[derive(Debug, Clone)]
pub struct ParameterInfo {
    /// Parameter index
    pub index: usize,

    /// Parameter name
    pub name: String,

    /// Minimum value
    pub min: f32,

    /// Maximum value
    pub max: f32,

    /// Default value
    pub default: f32,

    /// Unit label (e.g., "dB", "Hz", "%")
    pub unit: String,
}

impl ParameterInfo {
    /// Create a new ParameterInfo
    pub fn new(
        index: usize,
        name: String,
        min: f32,
        max: f32,
        default: f32,
        unit: String,
    ) -> Self {
        Self {
            index,
            name,
            min,
            max,
            default,
            unit,
        }
    }
}

/// Information about a plugin preset
#[derive(Debug, Clone)]
pub struct PresetInfo {
    /// Preset index (for enumeration)
    pub index: usize,

    /// Preset name
    pub name: String,

    /// Preset number (AudioUnit-specific identifier used for loading)
    pub preset_number: i32,
}

impl PresetInfo {
    /// Create a new PresetInfo
    pub fn new(index: usize, name: String, preset_number: i32) -> Self {
        Self {
            index,
            name,
            preset_number,
        }
    }
}