mkaudiolibrary 0.1.1

Modular audio processing library including MKAU plugin format based on Rust.
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

extern crate libloading;

use std::ops::Add;
use std::sync::{Arc, Barrier};
use libloading::{Library, Symbol};
use crate::buffer::CircularBuffer;

/// # Use
/// ```
/// use std::sync::{Arc, Barrier};
/// use mkaudiolibrary::buffer::*;
/// use mkaudiolibrary::processor::*;
///
/// #[derive(Debug, Default)]
/// struct Plugin;
/// impl Plugin
/// {
///     fn new() -> Self
///     {
///         todo!()
///     }
/// }
/// impl Processor for Plugin
/// {
///     fn init(&mut self)
///     {
///         todo!()
///     }
///
///     fn name(&self) -> String
///     {
///         todo!()
///     }
///
/// fn get_parameter(&self, index: usize) -> f64
///     {
///         todo!()
///     }
///
/// fn set_parameter(&mut self, index: usize, value: f64)
///     {
///         todo!()
///     }
///
/// fn run(&self, input: &mut Box<[CircularBuffer<Option<f64>>]>, sidechain_in: &mut Option<CircularBuffer<Option<f64>>>, output: &mut Box<[CircularBuffer<Option<f64>>]>, sidechain_out: &mut Option<CircularBuffer<Option<f64>>>, next: Arc<Barrier>, state: Arc<bool>)
///     {
///         todo!()
///     }
///
/// }
/// mkaudiolibrary::declare_plugin!(Plugin, Plugin::new());
/// ```

///Declare plugin.
#[macro_export]
macro_rules! declare_plugin
{
    ($plugin_type:ty, $constructor:path) =>
    {
        #[no_mangle]
        pub extern "C" fn _create() -> * mut dyn Processor
        {
            // make sure the constructor is the correct type.
            let constructor : fn() -> plugin_type = constructor;
            let object = constructor();
            let boxed : Box<dyn Processor> = Box::new(object);
            return Box::into_raw(boxed);
        }
    };
}
pub trait Processor
{
    ///Initialize processor when loaded.
    fn init(& mut self);
    ///Returns name.
    fn name(& self) -> String;
    ///Get parameter value of index.
    fn get_parameter(& self, index : usize) -> f64;
    ///Set parameter value of index.
    fn set_parameter(& mut self, index : usize, value : f64);
    ///Process with the plugin. Optional sidechain I/O, barrier for multithreading to pause by buffer size. State to stop.
    fn run(& self, input: & mut Box<[CircularBuffer<Option<f64>>]>, sidechain_in : & mut Option<CircularBuffer<Option<f64>>>,
           output: & mut Box<[CircularBuffer<Option<f64>>]>, sidechain_out : & mut Option<CircularBuffer<Option<f64>>>,
           next : Arc<Barrier>, state : Arc<bool>);
}
///Loads plugin.
pub fn load(filename : String) -> Result<Box<dyn Processor>, Box<dyn std::error::Error>>
{
    unsafe
        {
            let lib = Library::new(filename.add(".mkap").as_str())?;
            let constructor : Symbol<unsafe extern fn() -> * mut dyn Processor> = lib.get(b"_create\0")?;
            let mut plugin = Box::from_raw(constructor());
            plugin.init();
            Ok(plugin)
        }
}