lyd 0.0.2

Music dsp library written in Rust with a focus on performance and elegancy.
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

#![cfg_attr(feature = "no_std", no_std)]

pub mod enums;
pub use crate::enums::*;

// pub mod macros;
// pub use crate::macros::*;

pub mod params;
pub use crate::params::*;

use hashbrown::HashMap;
use smallvec::{smallvec, SmallVec};

pub type Buffer = SmallVec<[SmallVec<[f32; 1024]>; 2]>;
pub type Signal = SmallVec<[Nodes; 8]>; // Nodes is a enum

// #[derive(Debug)]
// pub struct ProcessOrder {
//     pub row: usize,
//     pub column: usize,
//     pub sidechain_buf: SmallVec<[usize; 64]>,
// }

pub fn context() -> Context {
    Context::new()
}

pub struct Context {
    pub sr: u32,
    pub frames: usize,
    pub channels: usize,
    pub signals: HashMap<&'static str, Signal>,
    pub buffers: HashMap<&'static str, Buffer>,
    // pub signals: SmallVec<[Signal; 4]>,
    // pub buffers: SmallVec<[Buffer; 4]>,
    // pub process_order: SmallVec<[ProcessOrder; 1024]>, // 64*16
}

impl Context {
    pub fn new() -> Self {
        Self {
            sr: 44100,
            frames: 128,
            channels: 2,
            signals: HashMap::new(),
            buffers: HashMap::new(),
            // signals: smallvec![],
            // buffers: smallvec![],
            // process_order: smallvec![],
        }
    }

    pub fn frames(mut self, frames: usize) -> Self {
        self.frames = frames;
        self
    }

    pub fn channels(mut self, channels: usize) -> Self {
        self.channels = channels;
        self
    }

    pub fn sr(mut self, sr: u32) -> Self {
        self.sr = sr;
        self
    }

    pub fn build(mut self, signals: &[(&'static str, &[NodeConfig])]) -> Self {
        for (_row, chain) in signals.iter().enumerate() {
            let (refname, signal) = chain;
            // self.signals.push(smallvec![]);
            let mut sig = smallvec![];
            for (_, node) in signal.iter().enumerate() {
                match node {
                    NodeConfig::SinOsc(config) => {
                        sig.push(Nodes::SinOsc(SinOscStruct {
                            freq: config.freq,
                            phase: config.phase.as_float(),
                            amp: config.amp.as_float(),
                            sr: self.sr,
                        }));
                    }
                    NodeConfig::Add(config) => {
                        sig.push(Nodes::Add(AddStruct { add: config.add }));
                    }
                }
            }
            self.signals.insert(refname, sig);
            self.buffers.insert(
                refname,
                smallvec![smallvec![0.0; self.frames]; self.channels],
            );
        }
        self
    }

    pub fn next_block(&mut self) -> &mut Buffer {
        //-> &mut Buffer
        // println!("self.process_order {:?}", &self.process_order);
        let ctx = self as *const Self;
        for (refname, signal) in self.signals.iter_mut() {
            // let signal = &mut self.signal.get_mut(key).unwrap();
            let buf = &mut self.buffers.get_mut(refname).unwrap();

            for node in signal.iter_mut() {
                match node {
                    Nodes::SinOsc(node) => node.process(
                        buf,
                        Some(unsafe { &(&*ctx).buffers } as *const HashMap<&'static str, Buffer>),
                    ),
                    Nodes::Add(node) => node.process(buf, None),
                }
            }
        }
        // for order in &self.process_order {
        //     let buf = &mut self.buffers[order.row];
        //     let signal = &mut self.signals[order.row];
        //     for node in signal {
        //         match node {
        //             Nodes::SinOsc(node) => node.process(
        //                 buf,
        //                 Some(unsafe { &(&*ctx).buffers } as *const SmallVec<[Buffer; 4]>),
        //             ),
        //             Nodes::Add(node) => node.process(buf, None),
        //         }
        //     }
        // }
        self.buffers.get_mut("out").unwrap()
    }
}