maolan-engine 0.2.32

Audio engine for the Maolan DAW with audio/MIDI tracks, routing, export, and out-of-process CLAP/VST3/LV2 plugin support
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

#[cfg(target_os = "macos")]
use crate::clap::ClapMidiOutputEvent;

use std::sync::Arc;

pub struct ClapInstance {
    pub id: usize,
    pub processor: crate::clap_proc::SharedClapProcessor,
}

impl std::fmt::Debug for ClapInstance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ClapInstance")
            .field("id", &self.id)
            .field("processor", &"<SharedClapProcessor>")
            .finish()
    }
}

impl ClapInstance {
    pub(crate) fn new(id: usize, processor: crate::clap_proc::SharedClapProcessor) -> Self {
        Self { id, processor }
    }
}

pub struct Vst3Instance {
    pub id: usize,
    pub processor: crate::vst3_proc::SharedVst3Processor,
}

impl std::fmt::Debug for Vst3Instance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Vst3Instance")
            .field("id", &self.id)
            .field("processor", &"<SharedVst3Processor>")
            .finish()
    }
}

impl Vst3Instance {
    pub(crate) fn new(id: usize, processor: crate::vst3_proc::SharedVst3Processor) -> Self {
        Self { id, processor }
    }
}

#[cfg(all(unix, not(target_os = "macos")))]
pub struct Lv2Instance {
    pub id: usize,
    pub processor: crate::lv2_proc::SharedLv2Processor,
}

#[cfg(all(unix, not(target_os = "macos")))]
impl std::fmt::Debug for Lv2Instance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Lv2Instance")
            .field("id", &self.id)
            .field("processor", &"<SharedLv2Processor>")
            .finish()
    }
}

#[cfg(all(unix, not(target_os = "macos")))]
impl Lv2Instance {
    pub(crate) fn new(id: usize, processor: crate::lv2_proc::SharedLv2Processor) -> Self {
        Self { id, processor }
    }
}

impl crate::connectable::AudioPorts for ClapInstance {
    fn audio_inputs(&self) -> Vec<Arc<crate::audio::io::AudioIO>> {
        self.processor.audio_inputs().to_vec()
    }

    fn audio_outputs(&self) -> Vec<Arc<crate::audio::io::AudioIO>> {
        self.processor.audio_outputs().to_vec()
    }
}

impl crate::connectable::MidiPorts for ClapInstance {
    fn midi_inputs(&self) -> Vec<Arc<crate::midi::io::MIDIIO>> {
        self.processor.midi_input_ports().to_vec()
    }

    fn midi_outputs(&self) -> Vec<Arc<crate::midi::io::MIDIIO>> {
        self.processor.midi_output_ports().to_vec()
    }
}

impl crate::connectable::AudioPorts for Vst3Instance {
    fn audio_inputs(&self) -> Vec<Arc<crate::audio::io::AudioIO>> {
        self.processor.audio_inputs().to_vec()
    }

    fn audio_outputs(&self) -> Vec<Arc<crate::audio::io::AudioIO>> {
        self.processor.audio_outputs().to_vec()
    }
}

impl crate::connectable::MidiPorts for Vst3Instance {
    fn midi_inputs(&self) -> Vec<Arc<crate::midi::io::MIDIIO>> {
        self.processor.midi_input_ports().to_vec()
    }

    fn midi_outputs(&self) -> Vec<Arc<crate::midi::io::MIDIIO>> {
        self.processor.midi_output_ports().to_vec()
    }
}

#[cfg(all(unix, not(target_os = "macos")))]
impl crate::connectable::AudioPorts for Lv2Instance {
    fn audio_inputs(&self) -> Vec<Arc<crate::audio::io::AudioIO>> {
        self.processor.audio_inputs().to_vec()
    }

    fn audio_outputs(&self) -> Vec<Arc<crate::audio::io::AudioIO>> {
        self.processor.audio_outputs().to_vec()
    }
}

#[cfg(all(unix, not(target_os = "macos")))]
impl crate::connectable::MidiPorts for Lv2Instance {
    fn midi_inputs(&self) -> Vec<Arc<crate::midi::io::MIDIIO>> {
        self.processor.midi_input_ports().to_vec()
    }

    fn midi_outputs(&self) -> Vec<Arc<crate::midi::io::MIDIIO>> {
        self.processor.midi_output_ports().to_vec()
    }
}