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

use std::ops::Range;

use crate::{
    channel::ChannelPosition,
    event::{Events, EventsFrame, EventsMut},
    signal::{Signals, SignalsMut, SingalsFrame},
    time::SampleRateBaseType,
};

/// Private module
/// Frame is the sotrage required by output ports during a session

#[derive(Clone)]
pub enum Frame {
    Events(EventsFrame),
    Signals(SingalsFrame),
}

impl Frame {
    pub fn reset(&mut self) {
        match self {
            Self::Events(frame) => frame.clear(),
            Self::Signals(frame) => frame.reset(),
        }
    }

    #[must_use]
    pub const fn get_events(&self, sr: SampleRateBaseType) -> Option<Events<'_>> {
        match self {
            Self::Events(events) => Some(Events::new(sr, events)),
            Self::Signals(_) => None,
        }
    }

    #[must_use]
    pub fn get_events_mut(&mut self, sr: SampleRateBaseType) -> Option<EventsMut<'_>> {
        match self {
            Self::Events(events) => Some(EventsMut::new(sr, events)),
            Self::Signals(_) => None,
        }
    }

    #[must_use]
    pub const fn get_signals(&self, range: Range<usize>) -> Option<Signals<'_>> {
        match self {
            Self::Signals(frame) => Some(Signals::new(range, frame)),
            Self::Events(_) => None,
        }
    }

    #[must_use]
    pub const fn get_signals_mut(&mut self, range: Range<usize>) -> Option<SignalsMut<'_>> {
        match self {
            Self::Signals(frame) => Some(SignalsMut::new(range, frame)),
            Self::Events(_) => None,
        }
    }

    pub fn get_mono(&self, range: Range<usize>) -> Option<&[f32]> {
        match self {
            Self::Signals(frame) => frame
                .signals
                .iter()
                .find(|(ch, _)| *ch == ChannelPosition::FrontLeft)
                .map(|(_, buffer)| &buffer[range]),
            Self::Events(_) => None,
        }
    }
}