Merge pull request #470 from orottier/feature/audioparam-various

AudioParam validations, compound limits, optimizations for single-valued params

Author: orottier

benches/my_benchmark.rs

@@ -50,6 +50,17 @@ pub fn bench_audio_buffer_decode() {
     assert_eq!(buffer.length(), 101129);
 }
 
+pub fn bench_constant_source() {
+    let mut ctx = OfflineAudioContext::new(2, black_box(SAMPLES), SAMPLE_RATE);
+    let mut src = ctx.create_constant_source();
+
+    src.connect(&ctx.destination());
+    src.start_at(1.);
+    src.stop_at(9.);
+
+    assert_eq!(ctx.start_rendering_sync().length(), SAMPLES);
+}
+
 pub fn bench_sine() {
     let mut ctx = OfflineAudioContext::new(2, black_box(SAMPLES), SAMPLE_RATE);
     let mut osc = ctx.create_oscillator();
@@ -301,6 +312,7 @@ macro_rules! iai_or_criterion {
 iai_or_criterion!(
     bench_ctor,
     bench_audio_buffer_decode,
+    bench_constant_source,
     bench_sine,
     bench_sine_gain,
     bench_sine_gain_delay,

src/node/biquad_filter.rs

@@ -14,8 +14,8 @@ use crate::{MAX_CHANNELS, RENDER_QUANTUM_SIZE};
 
 use super::{AudioNode, ChannelConfig, ChannelConfigOptions};
 
-fn get_computed_freq(freq: f32, detune: f32) -> f32 {
-    freq * (detune / 1200.).exp2()
+fn get_computed_freq(freq: f32, detune: f32, sample_rate: f32) -> f32 {
+    freq * (detune / 1200.).exp2().clamp(0., sample_rate / 2.)
 }
 
 /// Biquad filter coefficients normalized against a0
@@ -490,7 +490,8 @@ impl BiquadFilterNode {
         let q = self.q().value();
 
         // get coefs
-        let computed_freq = get_computed_freq(frequency, detune);
+        let computed_freq = get_computed_freq(frequency, detune, sample_rate);
+
         let Coefficients { b0, b1, b2, a1, a2 } = calculate_coefs(
             type_,
             sample_rate as f64,
@@ -614,7 +615,7 @@ impl AudioProcessor for BiquadFilterRenderer {
         let gain = params.get(&self.gain);
         let sample_rate_f64 = f64::from(sample_rate);
         // compute first coef and fill the coef list with this value
-        let computed_freq = get_computed_freq(frequency[0], detune[0]);
+        let computed_freq = get_computed_freq(frequency[0], detune[0], sample_rate);
         let coef = calculate_coefs(
             type_,
             sample_rate_f64,
@@ -635,7 +636,7 @@ impl AudioProcessor for BiquadFilterRenderer {
                 .zip(gain.iter().cycle())
                 .skip(1)
                 .for_each(|((((coefs, &f), &d), &q), &g)| {
-                    let computed_freq = get_computed_freq(f, d);
+                    let computed_freq = get_computed_freq(f, d, sample_rate);
                     *coefs = calculate_coefs(
                         type_,
                         sample_rate_f64,
@@ -703,15 +704,16 @@ mod tests {
 
     #[test]
     fn test_computed_freq() {
+        let sample_rate = 48000.;
         let g_sharp = 415.3;
         let a = 440.;
         let b_flat = 466.16;
 
         // 100 cents is 1 semi tone up
-        let res = get_computed_freq(a, 100.);
+        let res = get_computed_freq(a, 100., sample_rate);
         assert_float_eq!(res, b_flat, abs <= 0.01);
         // -100 cents is 1 semi tone below
-        let res = get_computed_freq(a, -100.);
+        let res = get_computed_freq(a, -100., sample_rate);
         assert_float_eq!(res, g_sharp, abs <= 0.01);
     }
 

src/node/constant_source.rs

@@ -201,23 +201,33 @@ impl AudioProcessor for ConstantSourceRenderer {
 
         let offset = params.get(&self.offset);
         let output_channel = output.channel_data_mut(0);
-        let mut current_time = scope.current_time;
-
-        output_channel
-            .iter_mut()
-            .zip(offset.iter().cycle())
-            .for_each(|(o, &value)| {
-                if current_time < self.start_time || current_time >= self.stop_time {
-                    *o = 0.;
-                } else {
-                    // as we pick values directly from the offset param which is already
-                    // computed at sub-sample accuracy, we don't need to do more than
-                    // copying the values to their right place.
-                    *o = value;
-                }
-
-                current_time += dt;
-            });
+
+        // fast path
+        if offset.len() == 1
+            && self.start_time <= scope.current_time
+            && self.stop_time >= next_block_time
+        {
+            output_channel.fill(offset[0]);
+        } else {
+            // sample accurate path
+            let mut current_time = scope.current_time;
+
+            output_channel
+                .iter_mut()
+                .zip(offset.iter().cycle())
+                .for_each(|(o, &value)| {
+                    if current_time < self.start_time || current_time >= self.stop_time {
+                        *o = 0.;
+                    } else {
+                        // as we pick values directly from the offset param which is already
+                        // computed at sub-sample accuracy, we don't need to do more than
+                        // copying the values to their right place.
+                        *o = value;
+                    }
+
+                    current_time += dt;
+                });
+        }
 
         // tail_time false when output has ended this quantum
         let still_running = self.stop_time >= next_block_time;

src/node/oscillator.rs

@@ -14,6 +14,12 @@ use super::{
     ChannelConfigOptions, TABLE_LENGTH_USIZE,
 };
 
+fn get_fase_incr(freq: f32, detune: f32, sample_rate: f64) -> f64 {
+    let computed_freq = freq as f64 * (detune as f64 / 1200.).exp2();
+    let clamped = computed_freq.clamp(-sample_rate / 2., sample_rate / 2.);
+    clamped / sample_rate
+}
+
 /// Options for constructing an [`OscillatorNode`]
 // dictionary OscillatorOptions : AudioNodeOptions {
 //   OscillatorType type = "sine";
@@ -404,52 +410,21 @@ impl AudioProcessor for OscillatorRenderer {
             self.start_time = current_time;
         }
 
-        channel_data
-            .iter_mut()
-            .zip(frequency_values.iter().cycle())
-            .zip(detune_values.iter().cycle())
-            .for_each(|((o, &frequency), &detune)| {
-                if current_time < self.start_time || current_time >= self.stop_time {
-                    *o = 0.;
-                    current_time += dt;
-
-                    return;
-                }
-
-                // @todo: we could avoid recompute that if both param lengths are 1
-                let computed_frequency = frequency * (detune / 1200.).exp2();
-
-                // first sample to render
-                if !self.started {
-                    // if start time was between last frame and current frame
-                    // we need to adjust the phase first
-                    if current_time > self.start_time {
-                        let phase_incr = computed_frequency as f64 / sample_rate;
-                        let ratio = (current_time - self.start_time) / dt;
-                        self.phase = Self::unroll_phase(phase_incr * ratio);
-                    }
-
-                    self.started = true;
-                }
-
-                let phase_incr = computed_frequency as f64 / sample_rate;
-
-                // @note: per spec all default oscillators should be rendered from a
-                // wavetable, define if it worth the assle...
-                // e.g. for now `generate_sine` and `generate_custom` are almost the sames
-                // cf. https://webaudio.github.io/web-audio-api/#oscillator-coefficients
-                *o = match self.type_ {
-                    OscillatorType::Sine => self.generate_sine(),
-                    OscillatorType::Sawtooth => self.generate_sawtooth(phase_incr),
-                    OscillatorType::Square => self.generate_square(phase_incr),
-                    OscillatorType::Triangle => self.generate_triangle(),
-                    OscillatorType::Custom => self.generate_custom(),
-                };
-
-                current_time += dt;
-
-                self.phase = Self::unroll_phase(self.phase + phase_incr);
-            });
+        if frequency_values.len() == 1 && detune_values.len() == 1 {
+            let phase_incr = get_fase_incr(frequency_values[0], detune_values[0], sample_rate);
+            channel_data
+                .iter_mut()
+                .for_each(|output| self.generate_sample(output, phase_incr, &mut current_time, dt));
+        } else {
+            channel_data
+                .iter_mut()
+                .zip(frequency_values.iter().cycle())
+                .zip(detune_values.iter().cycle())
+                .for_each(|((output, &f), &d)| {
+                    let phase_incr = get_fase_incr(f, d, sample_rate);
+                    self.generate_sample(output, phase_incr, &mut current_time, dt)
+                });
+        }
 
         true
     }
@@ -485,6 +460,50 @@ impl AudioProcessor for OscillatorRenderer {
 }
 
 impl OscillatorRenderer {
+    #[inline]
+    fn generate_sample(
+        &mut self,
+        output: &mut f32,
+        phase_incr: f64,
+        current_time: &mut f64,
+        dt: f64,
+    ) {
+        if *current_time < self.start_time || *current_time >= self.stop_time {
+            *output = 0.;
+            *current_time += dt;
+
+            return;
+        }
+
+        // first sample to render
+        if !self.started {
+            // if start time was between last frame and current frame
+            // we need to adjust the phase first
+            if *current_time > self.start_time {
+                let ratio = (*current_time - self.start_time) / dt;
+                self.phase = Self::unroll_phase(phase_incr * ratio);
+            }
+
+            self.started = true;
+        }
+
+        // @note: per spec all default oscillators should be rendered from a
+        // wavetable, define if it worth the assle...
+        // e.g. for now `generate_sine` and `generate_custom` are almost the sames
+        // cf. https://webaudio.github.io/web-audio-api/#oscillator-coefficients
+        *output = match self.type_ {
+            OscillatorType::Sine => self.generate_sine(),
+            OscillatorType::Sawtooth => self.generate_sawtooth(phase_incr),
+            OscillatorType::Square => self.generate_square(phase_incr),
+            OscillatorType::Triangle => self.generate_triangle(),
+            OscillatorType::Custom => self.generate_custom(),
+        };
+
+        *current_time += dt;
+
+        self.phase = Self::unroll_phase(self.phase + phase_incr);
+    }
+
     #[inline]
     fn generate_sine(&mut self) -> f32 {
         let position = self.phase * TABLE_LENGTH_USIZE as f64;

src/node/panner.rs

@@ -841,26 +841,28 @@ impl AudioProcessor for PannerRenderer {
                 && listener_up_z.len() == 1;
 
             if single_valued {
+                let param_value = a_rate_params.next().unwrap();
                 match input.number_of_channels() {
                     1 => {
                         *output = input.clone();
                         output.mix(2, ChannelInterpretation::Speakers);
                         let [left, right] = output.stereo_mut();
-                        std::iter::repeat(a_rate_params.next().unwrap())
-                            .zip(&mut left[..])
+                        left.iter_mut()
                             .zip(&mut right[..])
-                            .for_each(|((p, l), r)| apply_mono_to_stereo_gain(p, l, r));
+                            .for_each(|(l, r)| apply_mono_to_stereo_gain(param_value, l, r));
                     }
                     2 => {
                         output.set_number_of_channels(2);
                         let [left, right] = output.stereo_mut();
-                        std::iter::repeat(a_rate_params.next().unwrap())
-                            .zip(input.channel_data(0).iter().copied())
+                        input
+                            .channel_data(0)
+                            .iter()
+                            .copied()
                             .zip(input.channel_data(1).iter().copied())
                             .zip(&mut left[..])
                             .zip(&mut right[..])
-                            .for_each(|((((p, il), ir), ol), or)| {
-                                apply_stereo_to_stereo_gain(p, il, ir, ol, or)
+                            .for_each(|(((il, ir), ol), or)| {
+                                apply_stereo_to_stereo_gain(param_value, il, ir, ol, or)
                             });
                     }
                     _ => unreachable!(),