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

use std::ops::Range;

use crate::{
    channel::ChannelPositionsMask,
    event::Event,
    node::{NodeBuilderTrait, NodeCtx, NodeInputs, NodeOutputs, NodeTrait},
    nodes::{self, SimpleMixerProps},
    port::{PortId, PortProps, PortProxy, PortType},
};

#[derive(Clone)]
pub struct SimplePianoProps {
    channel_mask: ChannelPositionsMask,
    events: Vec<Event>,
}

impl SimplePianoProps {
    pub const PORT_ID_OUTPUT: PortId = PortId(0);

    #[must_use]
    pub const fn new(channel_mask: ChannelPositionsMask, events: Vec<Event>) -> Self {
        Self {
            channel_mask,
            events,
        }
    }
}

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

struct SimplePiano {
    port_props: Vec<PortProps>,
}

impl SimplePiano {
    fn new(ctx: &mut NodeCtx, props: SimplePianoProps) -> Self {
        // C4 or 440hz is base note with multiplier 1
        const PROPS: [(f32, f32); 4] = [
            (440f32 * std::f32::consts::TAU, 1f32),          // fundamental
            (440f32 * 2f32 * std::f32::consts::TAU, 0.9f32), // 1st harmonics
            (440f32 * 3f32 * std::f32::consts::TAU, 0.75f32), // 2nd harmonics
            (440f32 * 4f32 * std::f32::consts::TAU, 0.25f32), // 3rd harmonics
        ];
        let mut port_props = Vec::<PortProps>::with_capacity(1);
        let piano_roll_node_id = ctx
            .add_node(&nodes::PianoRollProps::new(props.events))
            .unwrap();
        let output_node_id = ctx
            .add_node(&nodes::SimpleMixerProps::new(
                props.channel_mask,
                vec![1f32; PROPS.len()],
            ))
            .unwrap();
        let output_node_output_port = ctx
            .get_node(output_node_id)
            .unwrap()
            .get_port(SimpleMixerProps::PORT_ID_OUTPUT)
            .unwrap();
        port_props.push(PortProps {
            id: SimpleMixerProps::PORT_ID_OUTPUT,
            kind: PortType::Proxy(PortProxy::new(0usize.into(), output_node_output_port)),
            auto_connect: true,
            name: "Output",
        });
        for (w, mul) in &PROPS {
            let id = ctx
                .add_node(&nodes::OscProps::new_sin(props.channel_mask, *w, *mul).unwrap())
                .unwrap();
            let _ = ctx.connect_nodes(piano_roll_node_id, id);
            let _ = ctx.connect_nodes(id, output_node_id);
        }
        Self { port_props }
    }
}

impl NodeTrait for SimplePiano {
    fn process(
        &mut self,
        _step_range: Range<usize>,
        _inputs: &NodeInputs,
        _outputs: &mut NodeOutputs,
    ) {
    }

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

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