Merge pull request #475 from orottier/feature/script-processor

ScriptProcessorNode

Author: orottier

examples/script_processor.rs

@@ -0,0 +1,47 @@
+use rand::Rng;
+
+use web_audio_api::context::{
+    AudioContext, AudioContextLatencyCategory, AudioContextOptions, BaseAudioContext,
+};
+use web_audio_api::node::{AudioNode, AudioScheduledSourceNode};
+
+// ScriptProcessorNode example
+//
+// `cargo run --release --example script_processor`
+//
+// If you are on Linux and use ALSA as audio backend backend, you might want to run
+// the example with the `WEB_AUDIO_LATENCY=playback ` env variable which will
+// increase the buffer size to 1024
+//
+// `WEB_AUDIO_LATENCY=playback cargo run --release --example script_processor`
+fn main() {
+    env_logger::init();
+
+    let latency_hint = match std::env::var("WEB_AUDIO_LATENCY").as_deref() {
+        Ok("playback") => AudioContextLatencyCategory::Playback,
+        _ => AudioContextLatencyCategory::default(),
+    };
+
+    let context = AudioContext::new(AudioContextOptions {
+        latency_hint,
+        ..AudioContextOptions::default()
+    });
+
+    let node = context.create_script_processor(512, 1, 1);
+    node.set_onaudioprocess(|e| {
+        let mut rng = rand::thread_rng();
+        e.output_buffer
+            .get_channel_data_mut(0)
+            .iter_mut()
+            .zip(e.input_buffer.get_channel_data(0))
+            .for_each(|(o, i)| *o = *i + rng.gen_range(-0.3..0.3));
+    });
+
+    let mut src = context.create_oscillator();
+    src.frequency().set_value(400.);
+    src.start();
+    src.connect(&node);
+    node.connect(&context.destination());
+
+    std::thread::sleep(std::time::Duration::from_millis(5000));
+}

src/context/base.rs

@@ -214,6 +214,30 @@ pub trait BaseAudioContext {
         PeriodicWave::new(self.base(), options)
     }
 
+    /// Creates an `ScriptProcessorNode` for custom audio processing (deprecated);
+    ///
+    /// # Panics
+    ///
+    /// This function panics if:
+    /// - `buffer_size` is not 256, 512, 1024, 2048, 4096, 8192, or 16384
+    /// - the number of input and output channels are both zero
+    /// - either of the channel counts exceed [`crate::MAX_CHANNELS`]
+    #[must_use]
+    fn create_script_processor(
+        &self,
+        buffer_size: usize,
+        number_of_input_channels: usize,
+        number_of_output_channels: usize,
+    ) -> node::ScriptProcessorNode {
+        let options = node::ScriptProcessorOptions {
+            buffer_size,
+            number_of_input_channels,
+            number_of_output_channels,
+        };
+
+        node::ScriptProcessorNode::new(self.base(), options)
+    }
+
     /// Creates an `StereoPannerNode` to pan a stereo output
     #[must_use]
     fn create_stereo_panner(&self) -> node::StereoPannerNode {

src/context/mod.rs

@@ -90,6 +90,7 @@ impl From<u8> for AudioContextState {
 /// This object allows for communication with the render thread and dynamic lifetime management.
 //
 // The only way to construct this object is by calling [`BaseAudioContext::register`]
+#[derive(Clone)]
 pub struct AudioContextRegistration {
     /// the audio context in which nodes and connections lives
     context: ConcreteBaseAudioContext,

src/events.rs

@@ -26,6 +26,7 @@ pub(crate) enum EventType {
     Diagnostics,
     Message(AudioNodeId),
     Complete,
+    AudioProcessing(AudioNodeId),
 }
 
 /// The Error Event interface
@@ -40,6 +41,19 @@ pub struct ErrorEvent {
     pub event: Event,
 }
 
+/// The AudioProcessingEvent interface
+#[non_exhaustive]
+#[derive(Debug)]
+pub struct AudioProcessingEvent {
+    /// The input buffer
+    pub input_buffer: AudioBuffer,
+    /// The output buffer
+    pub output_buffer: AudioBuffer,
+    /// The time when the audio will be played in the same time coordinate system as the
+    /// AudioContext's currentTime.
+    pub playback_time: f64,
+}
+
 /// The OfflineAudioCompletionEvent Event interface
 #[non_exhaustive]
 #[derive(Debug)]
@@ -59,6 +73,7 @@ pub(crate) enum EventPayload {
     Message(Box<dyn Any + Send + 'static>),
     AudioContextState(AudioContextState),
     Complete(AudioBuffer),
+    AudioProcessing(AudioProcessingEvent),
 }
 
 #[derive(Debug)]
@@ -123,6 +138,13 @@ impl EventDispatch {
             payload: EventPayload::Complete(buffer),
         }
     }
+
+    pub fn audio_processing(id: AudioNodeId, value: AudioProcessingEvent) -> Self {
+        EventDispatch {
+            type_: EventType::AudioProcessing(id),
+            payload: EventPayload::AudioProcessing(value),
+        }
+    }
 }
 
 pub(crate) enum EventHandler {

src/lib.rs

@@ -31,7 +31,7 @@ pub mod media_streams;
 pub mod node;
 
 mod events;
-pub use events::{ErrorEvent, Event, OfflineAudioCompletionEvent};
+pub use events::*;
 
 mod message_port;
 pub use message_port::MessagePort;

src/node/mod.rs

@@ -47,6 +47,8 @@ mod oscillator;
 pub use oscillator::*;
 mod panner;
 pub use panner::*;
+mod script_processor;
+pub use script_processor::*;
 mod stereo_panner;
 pub use stereo_panner::*;
 mod waveshaper;