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

use std::ops::Range;

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

#[derive(Default, Clone)]
pub struct StereoProps {}

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

    const PORT_PROPS: [PortProps; 2] = [
        PortProps {
            id: Self::PORT_ID_INPUT,
            kind: PortType::SignalIn,
            auto_connect: true,
            name: "Input",
        },
        PortProps {
            id: Self::PORT_ID_OUTPUT,
            kind: PortType::SignalOut(
                ChannelPositionsMask::from_bits(
                    ChannelPositionsMask::FRONT_LEFT.bits()
                        | ChannelPositionsMask::FRONT_RIGHT.bits(),
                )
                .unwrap(),
            ),
            auto_connect: true,
            name: "Output",
        },
    ];
}

impl NodeBuilderTrait for StereoProps {
    fn build(&self, _ctx: &mut NodeCtx) -> Box<dyn NodeTrait> {
        Box::new(Stereo::default())
    }
}

#[derive(Default)]
struct Stereo {}

impl NodeTrait for Stereo {
    fn process(
        &mut self,
        step_range: Range<usize>,
        inputs: &NodeInputs,
        outputs: &mut NodeOutputs,
    ) {
        let mut output = outputs
            .get_signals_mut(StereoProps::PORT_ID_OUTPUT)
            .unwrap();
        let input = inputs.get_signals(StereoProps::PORT_ID_INPUT);
        if let Some(input) = input
            && let Some(signal) = input.get(ChannelPosition::FrontLeft)
        {
            for (i, _) in step_range.enumerate() {
                output.get_mut(ChannelPosition::FrontLeft).unwrap()[i] += signal[i];
                output.get_mut(ChannelPosition::FrontRight).unwrap()[i] += signal[i];
            }
        }
    }

    fn port_props(&self) -> &[PortProps] {
        &StereoProps::PORT_PROPS
    }

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