dhwani 0.1.1

A real-time audio processing engine for DAWs
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

use crate::{
    channel::{ChannelPosition, ChannelPositionsMask},
    node::{NodeBuilderTrait, NodeCtx, NodeInputs, NodeOutputs, NodeTrait},
    port::{PortId, PortProps, PortType},
    time::{ResolvedTimeRange, TimeUnit},
};

#[derive(Clone)]
pub struct SimpleDelayProps {
    channel_mask: ChannelPositionsMask,
    delay: TimeUnit,
    mul: f32,
}

impl SimpleDelayProps {
    pub const PORT_ID_INPUT: PortId = PortId(0);
    pub const PORT_ID_OUTPUT: PortId = PortId(1);

    #[must_use]
    pub const fn new(channel_mask: ChannelPositionsMask, delay: TimeUnit, mul: f32) -> Self {
        Self {
            channel_mask,
            delay,
            mul,
        }
    }
}

impl NodeBuilderTrait for SimpleDelayProps {
    fn build(&self, ctx: &mut NodeCtx) -> Box<dyn NodeTrait> {
        Box::new(SimpleDelay::new(ctx, self.clone()))
    }
}

struct SimpleDelay {
    chs: Vec<ChannelPosition>,
    buffer_size: usize,
    buffers: Vec<Vec<f32>>,
    props: SimpleDelayProps,
    port_props: Vec<PortProps>,
}

impl SimpleDelay {
    #[must_use]
    fn new(ctx: &NodeCtx, props: SimpleDelayProps) -> Self {
        let chs = Vec::<ChannelPosition>::from(props.channel_mask);
        let port_props = vec![
            PortProps {
                id: SimpleDelayProps::PORT_ID_INPUT,
                kind: PortType::SignalIn,
                auto_connect: true,
                name: "Input",
            },
            PortProps {
                id: SimpleDelayProps::PORT_ID_OUTPUT,
                kind: PortType::SignalOut(props.channel_mask),
                auto_connect: true,
                name: "Output",
            },
        ];
        let buffer_size = ctx.buffer_size() + props.delay.to_samples(ctx.sample_rate()) as usize;
        let mut buffers = Vec::<Vec<f32>>::with_capacity(chs.len());
        for _ in 0..chs.len() {
            buffers.push(vec![0f32; buffer_size]);
        }
        Self {
            chs,
            buffer_size,
            buffers,
            props,
            port_props,
        }
    }
}

impl NodeTrait for SimpleDelay {
    fn process(
        &mut self,
        time_range: ResolvedTimeRange,
        inputs: &NodeInputs,
        outputs: &mut NodeOutputs,
    ) {
        let mut output = outputs
            .get_signals_mut(SimpleDelayProps::PORT_ID_OUTPUT)
            .unwrap();
        for (i, &ch) in self.chs.iter().enumerate() {
            for (j, _) in time_range.into_iter().enumerate() {
                output.get_mut(ch).unwrap()[j] += self.buffers[i][j];
            }
            // Shift buffer
            self.buffers[i].copy_within(time_range.duraiton().., 0usize);
        }
        let old = self.buffer_size - time_range.duraiton();
        let input = inputs.get_signals(SimpleDelayProps::PORT_ID_INPUT);
        if let Some(input) = input {
            for (i, &ch) in self.chs.iter().enumerate() {
                if let Some(signal) = input.get(ch) {
                    let stop = old + signal.len();
                    for (j, val) in &mut self.buffers[i][old..stop].iter_mut().enumerate() {
                        *val = signal[j] * self.props.mul;
                    }
                    self.buffers[i][stop..].fill(0f32);
                } else {
                    self.buffers[i][old..].fill(0f32);
                }
            }
        } else {
            for i in 0..self.chs.len() {
                self.buffers[i][old..].fill(0f32);
            }
        }
    }

    fn port_props(&self) -> &[PortProps] {
        &self.port_props
    }

    fn name(&self) -> &'static str {
        "Simple Delay"
    }
}