nice-plug-au2 0.1.0

Audio Unit (AU2) support for nice-plug
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

use std::sync::Arc;

use crate::audio_setup::{AudioIOLayout, BufferConfig, BusInfo};

#[path = "instance_types.rs"]
mod types;
use crate::error::PluginResult;
use nice_plug_core::params::Params;
pub use types::{NiceAu2EditorHandle, ParameterInfo};

pub trait NicePluginInstance: Send + 'static {
    fn allocate_render_resources(
        &mut self,
        audio_io_layout: &AudioIOLayout,
        buffer_config: &BufferConfig,
    ) -> PluginResult<()>;

    fn deallocate_render_resources(&mut self);

    fn is_prepared(&self) -> bool;

    fn sample_rate(&self) -> Option<f64>;

    fn max_frames(&self) -> Option<u32>;

    fn params(&self) -> Arc<dyn Params>;

    fn save_state(&self) -> Vec<u8>;

    fn load_state(&mut self, data: &[u8]) -> PluginResult<()>;

    fn reset(&mut self);

    fn tail_samples(&self) -> u32;

    fn latency_samples(&self) -> u32;

    fn process(
        &mut self,
        inputs: &[&[f32]],
        outputs: &mut [&mut [f32]],
        num_samples: usize,
    ) -> PluginResult<()>;

    fn process_scheduled(
        &mut self,
        inputs: &[&[f32]],
        outputs: &mut [&mut [f32]],
        num_samples: usize,
        events: &[crate::render::Au2ScheduledParameterEvent],
    ) -> PluginResult<()> {
        for event in events {
            self.set_parameter_value(event.parameter_address, event.end_value)?;
        }
        self.process(inputs, outputs, num_samples)
    }

    fn process_scheduled_with_events(
        &mut self,
        inputs: &[&[f32]],
        outputs: &mut [&mut [f32]],
        num_samples: usize,
        events: &[crate::render::Au2ScheduledParameterEvent],
        _context: crate::render::Au2ProcessEvents<'_>,
    ) -> PluginResult<()> {
        self.process_scheduled(inputs, outputs, num_samples, events)
    }

    fn process_f64(
        &mut self,
        inputs: &[&[f64]],
        outputs: &mut [&mut [f64]],
        num_samples: usize,
    ) -> PluginResult<()>;

    fn apply_parameter_events(
        &mut self,
        immediate: &[crate::render::Au2ParameterEvent],
        ramps: &[crate::render::Au2ParameterRampEvent],
    ) -> PluginResult<()>;

    fn input_bus_count(&self) -> usize;

    fn output_bus_count(&self) -> usize;

    fn input_bus_info(&self, index: usize) -> Option<BusInfo>;

    fn output_bus_info(&self, index: usize) -> Option<BusInfo>;

    fn parameter_count(&self) -> usize;

    fn parameter_info(&self, index: usize) -> Option<ParameterInfo>;

    fn parameter_value(&self, param_id: u32) -> Option<f32>;

    fn set_parameter_value(&mut self, param_id: u32, value: f32) -> PluginResult<()>;

    fn editor_size(&mut self) -> Option<(u32, u32)>;

    fn spawn_editor(&mut self, parent_ns_view: *mut std::ffi::c_void) -> *mut std::ffi::c_void;

    fn destroy_editor(&mut self, editor_handle: *mut std::ffi::c_void);

    fn flush_editor_notifications(&mut self);
}