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

use std::ops::Range;

use crate::{
    event::Event,
    node::{NodeBuilderTrait, NodeCtx, NodeInputs, NodeOutputs, NodeTrait},
    port::{PortId, PortProps, PortType},
};

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

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

    const PORT_PROPS: [PortProps; 1] = [PortProps {
        id: Self::PORT_ID_OUTPUT,
        kind: PortType::EventsOut,
        auto_connect: true,
        name: "Events",
    }];

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

impl NodeBuilderTrait for PianoRollProps {
    fn build(&self, ctx: &mut NodeCtx) -> Box<dyn NodeTrait> {
        let mut props = self.clone();
        let sr = ctx.sample_rate();
        props.events.sort_by_key(|event| event.time.to_samples(sr));
        Box::new(PianoRoll::new(props))
    }
}

struct PianoRoll {
    props: PianoRollProps,
}

impl PianoRoll {
    #[must_use]
    const fn new(props: PianoRollProps) -> Self {
        Self { props }
    }
}

impl NodeTrait for PianoRoll {
    fn process(
        &mut self,
        step_range: Range<usize>,
        _inputs: &NodeInputs,
        outputs: &mut NodeOutputs,
    ) {
        let mut output = outputs
            .get_events_mut(PianoRollProps::PORT_ID_OUTPUT)
            .unwrap();
        output.update(step_range, self.props.events.as_slice());
    }

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

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