firewheel-web-audio 0.1.0

A multi-threaded Web Audio backend for Firewheel
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

use firewheel::{
    clock::ClockSeconds, collector::ArcGc, node::StreamStatus, processor::FirewheelProcessor,
};
use js_sys::{Array, Float32Array};
use std::sync::atomic::AtomicBool;
use wasm_bindgen::{JsCast, prelude::wasm_bindgen};

#[wasm_bindgen]
pub(crate) struct ProcessorHost {
    pub(crate) processor: Option<FirewheelProcessor>,
    pub(crate) receiver: std::sync::mpsc::Receiver<FirewheelProcessor>,
    pub(crate) alive: ArcGc<AtomicBool>,
    pub(crate) inputs: usize,
    pub(crate) outputs: usize,
    pub(crate) input_buffers: &'static mut [f32],
    pub(crate) output_buffers: &'static mut [f32],
}

impl ProcessorHost {
    fn process_fallible(
        &mut self,
        inputs: js_sys::Array,
        outputs: js_sys::Array,
        current_time: f64,
    ) -> Result<bool, wasm_bindgen::JsValue> {
        if !self.alive.load(std::sync::atomic::Ordering::Relaxed) {
            return Ok(false);
        }

        if let Ok(processor) = self.receiver.try_recv() {
            self.processor = Some(processor);
        }

        // interleave
        let mut temp_buffer = [0f32; crate::BLOCK_FRAMES];
        for i in 0..self.inputs {
            let Ok(inputs) = inputs.get(0).dyn_into::<Array>() else {
                continue;
            };
            let Ok(channel_array) = inputs.get(i as u32).dyn_into::<Float32Array>() else {
                continue;
            };

            if channel_array.is_undefined() {
                return Err(wasm_bindgen::JsValue::undefined());
            }

            channel_array.copy_to(&mut temp_buffer);
            for (j, input) in temp_buffer.iter().enumerate() {
                let buffer_index = i + j * self.inputs;
                self.input_buffers[buffer_index] = *input;
            }
        }

        if let Some(processor) = &mut self.processor {
            processor.process_interleaved(
                self.input_buffers,
                self.output_buffers,
                self.inputs,
                self.outputs,
                crate::BLOCK_FRAMES,
                ClockSeconds(current_time),
                StreamStatus::empty(),
            );
        }

        // deinterleave
        for i in 0..self.outputs {
            let Ok(outputs) = outputs.get(0).dyn_into::<Array>() else {
                continue;
            };
            let Ok(channel_array) = outputs.get(i as u32).dyn_into::<Float32Array>() else {
                continue;
            };

            if channel_array.is_undefined() {
                return Err(wasm_bindgen::JsValue::undefined());
            }

            for (j, output) in temp_buffer.iter_mut().enumerate() {
                let buffer_index = i + j * self.outputs;
                *output = self.output_buffers[buffer_index];
            }

            channel_array.copy_from(&temp_buffer);
        }

        Ok(true)
    }
}

#[wasm_bindgen]
#[allow(dead_code)]
impl ProcessorHost {
    /// Pack the object to send through the web audio worklet constructor
    pub fn pack(self) -> usize {
        Box::into_raw(Box::new(self)) as usize
    }

    /// Unpack the object from the worklet constructor
    /// # Safety
    /// This should only be called within the worklet constructor from a known
    /// good pointer
    pub unsafe fn unpack(ptr: usize) -> Self {
        unsafe { *Box::from_raw(ptr as *mut Self) }
    }

    pub fn process(
        &mut self,
        inputs: js_sys::Array,
        outputs: js_sys::Array,
        current_time: f64,
    ) -> bool {
        // since we're in the audio context, it's difficult to
        // do anything but ignore the error
        self.process_fallible(inputs, outputs, current_time)
            .unwrap_or(true)
    }
}