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

use std::ops::Range;

use crate::channel::{ChannelPosition, ChannelPositionsMask};

#[derive(Clone)]
pub(crate) struct SingalsFrame {
    pub(crate) signals: Vec<(ChannelPosition, Vec<f32>)>,
}

impl SingalsFrame {
    pub(crate) fn new(channel_mask: ChannelPositionsMask, buffer_size: usize) -> Self {
        let n_channels = channel_mask.bits().count_ones() as usize;
        let mut signals = Vec::<(ChannelPosition, Vec<f32>)>::with_capacity(n_channels);
        for ch in channel_mask.iter() {
            let buffer = vec![0f32; buffer_size];
            signals.push((ch.try_into().unwrap(), buffer));
        }
        Self { signals }
    }

    pub(crate) fn reset(&mut self) {
        for (_, buffer) in &mut self.signals {
            buffer.fill(0f32);
        }
    }
}

pub struct SignalsMut<'a> {
    range: Range<usize>,
    frame: &'a mut SingalsFrame,
}

impl<'a> SignalsMut<'a> {
    pub(crate) const fn new(range: Range<usize>, frame: &'a mut SingalsFrame) -> Self {
        Self { range, frame }
    }

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

    pub fn clear(&mut self) {
        for (_, buffer) in &mut self.frame.signals {
            buffer[self.range.clone()].fill(0f32);
        }
    }

    #[must_use]
    pub fn get(&self, ch: ChannelPosition) -> Option<&[f32]> {
        self.frame
            .signals
            .iter()
            .find(|(c, _)| *c == ch)
            .map(|(_, buffer)| &buffer[self.range.clone()])
    }

    pub fn get_mut(&mut self, ch: ChannelPosition) -> Option<&mut [f32]> {
        self.frame
            .signals
            .iter_mut()
            .find(|(c, _)| *c == ch)
            .map(|(_, buffer)| &mut buffer[self.range.clone()])
    }
}

pub struct Signals<'a> {
    range: Range<usize>,
    frame: &'a SingalsFrame,
}

impl<'a> Signals<'a> {
    pub(crate) const fn new(range: Range<usize>, frame: &'a SingalsFrame) -> Self {
        Self { range, frame }
    }

    #[must_use]
    #[allow(clippy::cast_possible_truncation)]
    pub const fn n_channels(&self) -> u16 {
        self.frame.signals.len() as u16
    }

    #[must_use]
    pub fn get(&self, ch: ChannelPosition) -> Option<&[f32]> {
        self.frame
            .signals
            .iter()
            .find(|(c, _)| *c == ch)
            .map(|(_, buffer)| &buffer[self.range.clone()])
    }
}