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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use std::{ops::Range, sync::Arc};

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

#[derive(Clone)]
pub struct SampleInfo {
    id: usize,
    n_channels: u16,
    // No resampling implemented
    // sample_rate: SampleRateBaseType,
    n_samples_per_ch: usize,
    data: Arc<Vec<f32>>,
}

impl SampleInfo {
    #[must_use]
    pub const fn new(
        id: usize,
        n_channels: u16,
        // sample_rate: SampleRateBaseType,
        n_samples_per_ch: usize,
        data: Arc<Vec<f32>>,
    ) -> Self {
        Self {
            id,
            n_channels,
            // sample_rate,
            n_samples_per_ch,
            data,
        }
    }

    #[must_use]
    pub const fn id(&self) -> usize {
        self.id
    }

    #[must_use]
    pub const fn n_channels(&self) -> u16 {
        self.n_channels
    }

    // pub fn sample_rate(&self) -> SampleRateBaseType {
    //     self.sample_rate
    // }

    #[must_use]
    pub const fn n_samples_per_ch(&self) -> usize {
        self.n_samples_per_ch
    }

    #[must_use]
    pub fn data(&self) -> Arc<Vec<f32>> {
        self.data.clone()
    }
}

#[derive(Clone)]
pub struct SamplerProps {
    mul: f32,
    info: SampleInfo,
}

impl SamplerProps {
    pub const PORT_ID_MUL_CTRL: PortId = PortId(0);
    pub const PORT_ID_OUTPUT: PortId = PortId(1);

    /// Create new sampler builder props
    /// # Errors
    /// Will return if audio is not mono or stereo
    pub fn new(info: SampleInfo) -> Result<Self, Error> {
        if info.n_channels == 0 || info.n_channels > 2 {
            Err(Error::msg("Sampler only support mono or stereo".into()))
        } else {
            Ok(Self { mul: 1f32, info })
        }
    }
}

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

struct Sampler {
    chs: Vec<ChannelPosition>,
    props: SamplerProps,
    port_props: Vec<PortProps>,
}

impl Sampler {
    #[must_use]
    pub fn new(props: SamplerProps) -> Self {
        let channel_mask = if props.info.n_channels == 1 {
            ChannelPositionsMask::FRONT_LEFT
        } else if props.info.n_channels == 2 {
            ChannelPositionsMask::FRONT_LEFT | ChannelPositionsMask::FRONT_RIGHT
        } else {
            panic!("Sampler only support mono or stereo")
        };
        let chs = Vec::<ChannelPosition>::from(channel_mask);
        let port_props = vec![
            PortProps {
                id: SamplerProps::PORT_ID_MUL_CTRL,
                kind: PortType::SignalIn,
                auto_connect: true,
                name: "Multiplier",
            },
            PortProps {
                id: SamplerProps::PORT_ID_OUTPUT,
                kind: PortType::SignalOut(channel_mask),
                auto_connect: true,
                name: "Output",
            },
        ];
        Self {
            chs,
            props,
            port_props,
        }
    }
}

impl NodeTrait for Sampler {
    fn process(
        &mut self,
        step_range: Range<usize>,
        inputs: &NodeInputs,
        outputs: &mut NodeOutputs,
    ) {
        let n_channels = usize::from(self.props.info.n_channels);
        let mut output = outputs
            .get_signals_mut(SamplerProps::PORT_ID_OUTPUT)
            .unwrap();
        let mul = inputs.get_mono(SamplerProps::PORT_ID_MUL_CTRL);
        let start = step_range.start;
        let end = self.props.info.n_samples_per_ch.min(step_range.end);
        let len = end.saturating_sub(start);
        for &ch in &self.chs {
            let j = match ch {
                ChannelPosition::FrontLeft => 0usize,
                ChannelPosition::FrontRight => 1usize,
                _ => panic!("Sampler only support mono or stereo"),
            };
            for i in 0..len {
                let mul = self.props.mul + mul.as_ref().map_or(0f32, |mul| mul[i]);
                let val = self.props.info.data[((start + i) * n_channels) + j] * mul;
                output.get_mut(ch).unwrap()[i] += val;
            }
        }
    }

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

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