Merge pull request #476 from orottier/feature/rename-channelconfig-audionodeoption

Rename ChannelConfigOptions -> AudioNodeOptions

Author: orottier

examples/worklet_message_port.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 use web_audio_api::context::{
     AudioContext, AudioContextLatencyCategory, AudioContextOptions, BaseAudioContext,
 };
-use web_audio_api::node::{AudioNode, ChannelConfigOptions};
+use web_audio_api::node::{AudioNode, AudioNodeOptions};
 
 use web_audio_api::worklet::{
     AudioParamValues, AudioWorkletGlobalScope, AudioWorkletNode, AudioWorkletNodeOptions,
@@ -42,7 +42,7 @@ impl WhiteNoiseNode {
             output_channel_count: vec![1],
             parameter_data: HashMap::new(),
             processor_options: (),
-            channel_config: ChannelConfigOptions::default(),
+            audio_node_options: AudioNodeOptions::default(),
         };
 
         let node = AudioWorkletNode::new::<WhiteNoiseProcessor>(context.base(), options);

src/context/base.rs

@@ -7,7 +7,7 @@ use crate::context::{
 };
 use crate::decoding::MediaDecoder;
 use crate::events::{Event, EventHandler, EventType};
-use crate::node::{AudioNode, ChannelConfigOptions};
+use crate::node::{AudioNode, AudioNodeOptions};
 use crate::param::AudioParamDescriptor;
 use crate::periodic_wave::{PeriodicWave, PeriodicWaveOptions};
 use crate::{node, AudioListener};
@@ -186,7 +186,7 @@ pub trait BaseAudioContext {
     #[must_use]
     fn create_iir_filter(&self, feedforward: Vec<f64>, feedback: Vec<f64>) -> node::IIRFilterNode {
         let options = node::IIRFilterOptions {
-            channel_config: ChannelConfigOptions::default(),
+            audio_node_options: AudioNodeOptions::default(),
             feedforward,
             feedback,
         };

src/context/concrete_base.rs

@@ -6,7 +6,7 @@ use crate::context::{
 };
 use crate::events::{EventDispatch, EventHandler, EventLoop, EventType};
 use crate::message::ControlMessage;
-use crate::node::{AudioDestinationNode, AudioNode, ChannelConfig, ChannelConfigOptions};
+use crate::node::{AudioDestinationNode, AudioNode, AudioNodeOptions, ChannelConfig};
 use crate::param::AudioParam;
 use crate::render::AudioProcessor;
 use crate::spatial::AudioListenerParams;
@@ -144,7 +144,7 @@ impl ConcreteBaseAudioContext {
             render_channel: RwLock::new(render_channel),
             queued_messages: Mutex::new(Vec::new()),
             audio_node_id_provider,
-            destination_channel_config: ChannelConfigOptions::default().into(),
+            destination_channel_config: AudioNodeOptions::default().into(),
             frames_played,
             queued_audio_listener_msgs: Mutex::new(Vec::new()),
             listener_params: None,

src/context/mod.rs

@@ -85,7 +85,9 @@ impl From<u8> for AudioContextState {
 
 /// Handle of the [`AudioNode`](crate::node::AudioNode) to its associated [`BaseAudioContext`].
 ///
-/// This allows for communication with the render thread and lifetime management.
+/// Only when implementing the AudioNode trait manually, this struct is of any concern.
+///
+/// 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`]
 pub struct AudioContextRegistration {

src/context/online.rs

@@ -8,7 +8,7 @@ use crate::io::{self, AudioBackendManager, ControlThreadInit, NoneBackend, Rende
 use crate::media_devices::{enumerate_devices_sync, MediaDeviceInfoKind};
 use crate::media_streams::{MediaStream, MediaStreamTrack};
 use crate::message::{ControlMessage, OneshotNotify};
-use crate::node::{self, ChannelConfigOptions};
+use crate::node::{self, AudioNodeOptions};
 use crate::render::graph::Graph;
 use crate::MediaElement;
 use crate::{AudioRenderCapacity, Event};
@@ -576,7 +576,7 @@ impl AudioContext {
     /// Creates a [`MediaStreamAudioDestinationNode`](node::MediaStreamAudioDestinationNode)
     #[must_use]
     pub fn create_media_stream_destination(&self) -> node::MediaStreamAudioDestinationNode {
-        let opts = ChannelConfigOptions::default();
+        let opts = AudioNodeOptions::default();
         node::MediaStreamAudioDestinationNode::new(self, opts)
     }
 

src/node/analyser.rs

@@ -7,7 +7,7 @@ use crate::render::{
     AudioParamValues, AudioProcessor, AudioRenderQuantum, AudioWorkletGlobalScope,
 };
 
-use super::{AudioNode, ChannelConfig, ChannelConfigOptions, ChannelInterpretation};
+use super::{AudioNode, AudioNodeOptions, ChannelConfig, ChannelInterpretation};
 
 /// Options for constructing an [`AnalyserNode`]
 // dictionary AnalyserOptions : AudioNodeOptions {
@@ -22,7 +22,7 @@ pub struct AnalyserOptions {
     pub max_decibels: f64,
     pub min_decibels: f64,
     pub smoothing_time_constant: f64,
-    pub channel_config: ChannelConfigOptions,
+    pub audio_node_options: AudioNodeOptions,
 }
 
 impl Default for AnalyserOptions {
@@ -32,7 +32,7 @@ impl Default for AnalyserOptions {
             max_decibels: DEFAULT_MAX_DECIBELS,
             min_decibels: DEFAULT_MIN_DECIBELS,
             smoothing_time_constant: DEFAULT_SMOOTHING_TIME_CONSTANT,
-            channel_config: ChannelConfigOptions::default(),
+            audio_node_options: AudioNodeOptions::default(),
         }
     }
 }
@@ -123,7 +123,7 @@ impl AnalyserNode {
 
             let node = AnalyserNode {
                 registration,
-                channel_config: options.channel_config.into(),
+                channel_config: options.audio_node_options.into(),
                 analyser,
             };
 

src/node/biquad_filter.rs

@@ -12,7 +12,7 @@ use crate::render::{
 };
 use crate::{MAX_CHANNELS, RENDER_QUANTUM_SIZE};
 
-use super::{AudioNode, ChannelConfig, ChannelConfigOptions};
+use super::{AudioNode, AudioNodeOptions, ChannelConfig};
 
 fn get_computed_freq(freq: f32, detune: f32, sample_rate: f32) -> f32 {
     freq * (detune / 1200.).exp2().clamp(0., sample_rate / 2.)
@@ -235,7 +235,7 @@ pub struct BiquadFilterOptions {
     pub frequency: f32,
     pub gain: f32,
     pub type_: BiquadFilterType,
-    pub channel_config: ChannelConfigOptions,
+    pub audio_node_options: AudioNodeOptions,
 }
 
 impl Default for BiquadFilterOptions {
@@ -246,7 +246,7 @@ impl Default for BiquadFilterOptions {
             frequency: 350.,
             gain: 0.,
             type_: BiquadFilterType::default(),
-            channel_config: ChannelConfigOptions::default(),
+            audio_node_options: AudioNodeOptions::default(),
         }
     }
 }
@@ -351,7 +351,7 @@ impl BiquadFilterNode {
                 frequency,
                 gain,
                 type_,
-                channel_config,
+                audio_node_options: channel_config,
             } = options;
 
             let q_param_options = AudioParamDescriptor {

src/node/channel_merger.rs

@@ -6,9 +6,7 @@ use crate::render::{
 };
 use crate::MAX_CHANNELS;
 
-use super::{
-    AudioNode, ChannelConfig, ChannelConfigOptions, ChannelCountMode, ChannelInterpretation,
-};
+use super::{AudioNode, AudioNodeOptions, ChannelConfig, ChannelCountMode, ChannelInterpretation};
 
 /// Assert that the given number of channels is valid for a ChannelMergerNode
 ///
@@ -68,17 +66,17 @@ fn assert_valid_channel_count_mode(mode: ChannelCountMode) {
 #[derive(Clone, Debug)]
 pub struct ChannelMergerOptions {
     pub number_of_inputs: usize,
-    pub channel_config: ChannelConfigOptions,
+    pub audio_node_options: AudioNodeOptions,
 }
 
 impl Default for ChannelMergerOptions {
     fn default() -> Self {
         Self {
             number_of_inputs: 6,
-            channel_config: ChannelConfigOptions {
-                count: 1,
-                count_mode: ChannelCountMode::Explicit,
-                interpretation: ChannelInterpretation::Speakers,
+            audio_node_options: AudioNodeOptions {
+                channel_count: 1,
+                channel_count_mode: ChannelCountMode::Explicit,
+                channel_interpretation: ChannelInterpretation::Speakers,
             },
         }
     }
@@ -126,12 +124,12 @@ impl ChannelMergerNode {
         context.base().register(move |registration| {
             assert_valid_number_of_channels(options.number_of_inputs);
 
-            assert_valid_channel_count(options.channel_config.count);
-            assert_valid_channel_count_mode(options.channel_config.count_mode);
+            assert_valid_channel_count(options.audio_node_options.channel_count);
+            assert_valid_channel_count_mode(options.audio_node_options.channel_count_mode);
 
             let node = ChannelMergerNode {
                 registration,
-                channel_config: options.channel_config.into(),
+                channel_config: options.audio_node_options.into(),
                 number_of_inputs: options.number_of_inputs,
             };
 

src/node/channel_splitter.rs

@@ -6,9 +6,7 @@ use crate::render::{
 };
 use crate::MAX_CHANNELS;
 
-use super::{
-    AudioNode, ChannelConfig, ChannelConfigOptions, ChannelCountMode, ChannelInterpretation,
-};
+use super::{AudioNode, AudioNodeOptions, ChannelConfig, ChannelCountMode, ChannelInterpretation};
 
 /// Assert that the given number of channels is valid for a ChannelMergerNode
 ///
@@ -68,17 +66,17 @@ fn assert_valid_channel_interpretation(interpretation: ChannelInterpretation) {
 #[derive(Clone, Debug)]
 pub struct ChannelSplitterOptions {
     pub number_of_outputs: usize,
-    pub channel_config: ChannelConfigOptions,
+    pub audio_node_options: AudioNodeOptions,
 }
 
 impl Default for ChannelSplitterOptions {
     fn default() -> Self {
         Self {
             number_of_outputs: 6,
-            channel_config: ChannelConfigOptions {
-                count: 6, // must be same as number_of_outputs
-                count_mode: ChannelCountMode::Explicit,
-                interpretation: ChannelInterpretation::Discrete,
+            audio_node_options: AudioNodeOptions {
+                channel_count: 6, // must be same as number_of_outputs
+                channel_count_mode: ChannelCountMode::Explicit,
+                channel_interpretation: ChannelInterpretation::Discrete,
             },
         }
     }
@@ -133,14 +131,14 @@ impl ChannelSplitterNode {
     pub fn new<C: BaseAudioContext>(context: &C, mut options: ChannelSplitterOptions) -> Self {
         context.base().register(move |registration| {
             assert_valid_number_of_channels(options.number_of_outputs);
-            options.channel_config.count = options.number_of_outputs;
+            options.audio_node_options.channel_count = options.number_of_outputs;
 
-            assert_valid_channel_count_mode(options.channel_config.count_mode);
-            assert_valid_channel_interpretation(options.channel_config.interpretation);
+            assert_valid_channel_count_mode(options.audio_node_options.channel_count_mode);
+            assert_valid_channel_interpretation(options.audio_node_options.channel_interpretation);
 
             let node = ChannelSplitterNode {
                 registration,
-                channel_config: options.channel_config.into(),
+                channel_config: options.audio_node_options.into(),
             };
 
             let render = ChannelSplitterRenderer {

src/node/convolver.rs

@@ -10,7 +10,7 @@ use crate::render::{
 };
 use crate::RENDER_QUANTUM_SIZE;
 
-use super::{AudioNode, ChannelConfig, ChannelConfigOptions, ChannelInterpretation};
+use super::{AudioNode, AudioNodeOptions, ChannelConfig, ChannelInterpretation};
 
 /// Scale buffer by an equal-power normalization
 // see - <https://webaudio.github.io/web-audio-api/#dom-convolvernode-normalize>
@@ -65,7 +65,7 @@ pub struct ConvolverOptions {
     /// The opposite of the desired initial value for the normalize attribute
     pub disable_normalization: bool,
     /// AudioNode options
-    pub channel_config: ChannelConfigOptions,
+    pub audio_node_options: AudioNodeOptions,
 }
 
 /// Processing node which applies a linear convolution effect given an impulse response.
@@ -154,7 +154,7 @@ impl ConvolverNode {
         let ConvolverOptions {
             buffer,
             disable_normalization,
-            channel_config,
+            audio_node_options: channel_config,
         } = options;
 
         let mut node = context.base().register(move |registration| {