fluffl 0.0.5

A cross-platform multimedia layer that exposes opengl,sockets,and audio utilities for desktop and browser
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::ops::Deref;

use super::*;
use crate::audio::{AudioDeviceCore, DesiredSpecs, FlufflAudioContext, FlufflAudioDeviceContext};
use adhoc_audio::{StreamInfo, WavCodec};

pub type StandardMixerCB = fn(&mut StandardMixerState, &mut [f32]);

pub struct MixerAudioDeviceContext {
    protocol: MixerProtocol,
    device: FlufflAudioDeviceContext<StandardMixerCB, StandardMixerState>,
    local_requests: LocalRequestQueue,
    id_counter: u64,
}
impl MixerAudioDeviceContext {
    pub fn new(ctx: FlufflAudioContext) -> Self {
        let state = StandardMixerState::new(|state| {
            state.channels = 2;
            state.frequency = 44_100;
        });
        let protocol = state.protocol();
        Self {
            device: FlufflAudioDeviceContext::new(
                AudioDeviceCore::new()
                    .with_specs(DesiredSpecs {
                        sample_rate: Some(44_100),
                        channels: Some(2),
                        buffer_size: Some(2048),
                    })
                    .with_state(state)
                    .with_callback(standard_mixer_state_cb),
                ctx,
            ),
            protocol,
            local_requests: LocalRequestQueue::new(),
            id_counter: 0,
        }
    }

    /// ## Description
    /// generates a unique id for a track.
    /// ## Comments
    /// - ids are used to reference a track in the mixer
    pub fn gen_id(&mut self) -> TrackID {
        let id = self.id_counter;
        self.id_counter += 1;
        TrackID::from_u64(id)
    }

    pub fn dump_recording(&self) {
        // self.modify_state(|state|{
        //     let state = state?;
        //     let file = fs::File::create("mixer_dump.wav").ok()?;
        //     state.recording.save_to(file).ok()?;
        //     Some(())
        // });
    }

    /// ## Description
    /// Queues up a request
    /// ## Comments
    /// - You probably will not get a response back immediately after sending (may take multiple frames)
    /// - Once you send something **You must call ** `Self::recieve_responses(..)` to dequeue responses recieved from the mixer.
    ///     - if you dont call that function, response messages from the mixer will build up and eat your memory.
    pub fn send_request(&mut self, req: MixerRequest) {
        self.local_requests.enqueue(req);
        self.protocol.submit_requests(&mut self.local_requests);
    }

    /// ## Description
    /// Dequeues responses recived by the mixer
    pub fn recieve_responses(&mut self) -> impl Iterator<Item = MixerResponse> + '_ {
        self.protocol.recieve_responses()
    }
}

impl Deref for MixerAudioDeviceContext {
    type Target = FlufflAudioDeviceContext<StandardMixerCB, StandardMixerState>;
    fn deref(&self) -> &Self::Target {
        &self.device
    }
}
/// The standard mixer has a final output of 2 channels and a sampling rate of 44_100 hz
pub struct StandardMixerState {
    pub mixer: Mixer,
    pub channels: u32,
    pub frequency: u32,
    pub recording: WavCodec,
}

impl StandardMixerState {
    pub fn new<CB>(mut init: CB) -> Self
    where
        CB: FnMut(&mut Self),
    {
        let mixer = Mixer::new(44_100, 2);
        let mut state = Self {
            mixer,
            channels: 2,
            frequency: 44_100,
            recording: WavCodec::new(StreamInfo::new(44_100, 2)),
        };
        init(&mut state);
        state
    }
}

impl std::ops::Deref for StandardMixerState {
    type Target = Mixer;
    fn deref(&self) -> &Self::Target {
        &self.mixer
    }
}

impl std::ops::DerefMut for StandardMixerState {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.mixer
    }
}

/// the standard callback for a mixer
fn standard_mixer_state_cb(state: &mut StandardMixerState, output: &mut [f32]) {
    state.mixer.mix_audio(PCMSlice::new(
        output,
        state.frequency as u32,
        state.channels as u32,
    ));
    //for debug purposes
    // state.recording.encode(output);
}