configurable sample rate for fyrox-sound

Author: mrDIMAS

fyrox-impl/src/engine/mod.rs

@@ -315,7 +315,6 @@ pub struct Engine {
 
     model_events_receiver: Receiver<ResourceEvent>,
 
-    #[allow(dead_code)] // Keep engine instance alive.
     sound_engine: SoundEngine,
 
     // A set of plugins used by the engine.
@@ -1501,6 +1500,17 @@ impl Engine {
         }
     }
 
+    /// Returns current sample rate of the sound engine.
+    pub fn sound_sample_rate(&self) -> u32 {
+        self.sound_engine.sample_rate()
+    }
+
+    /// Normalizes given frequency using sampling rate of the sound output device. Normalized frequency
+    /// then can be used to create filters.
+    pub fn normalize_sound_frequency(&self, f: f32) -> f32 {
+        self.sound_engine.normalize_frequency(f)
+    }
+
     /// Tries to destroy current graphics context. It will succeed only if the `graphics_context` is fully initialized.
     /// The method will try to save all possible runtime changes of the window, so the next [`Engine::initialize_graphics_context`]
     /// will result in the almost exact copy of the context that was made before destruction.

fyrox-impl/src/scene/sound/context.rs

@@ -80,12 +80,6 @@ impl SoundContextGuard<'_> {
         self.guard.distance_model()
     }
 
-    /// Normalizes given frequency using context's sampling rate. Normalized frequency then can be used
-    /// to create filters.
-    pub fn normalize_frequency(&self, f: f32) -> f32 {
-        self.guard.normalize_frequency(f)
-    }
-
     /// Returns amount of time context spent on rendering all sound sources.
     pub fn full_render_duration(&self) -> Duration {
         self.guard.full_render_duration()

fyrox-impl/src/scene/sound/mod.rs

@@ -47,7 +47,7 @@ pub use fyrox_sound::{
         DataSource, SoundBuffer, SoundBufferResource, SoundBufferResourceLoadError,
     },
     bus::*,
-    context::{DistanceModel, SAMPLE_RATE},
+    context::DistanceModel,
     dsp::{filters::*, DelayLine},
     effects::*,
     engine::SoundEngine,

fyrox-sound/examples/hrtf.rs

@@ -26,7 +26,7 @@ use fyrox_sound::renderer::hrtf::{HrirSphereResource, HrirSphereResourceExt};
 use fyrox_sound::{
     algebra::{UnitQuaternion, Vector3},
     buffer::{DataSource, SoundBufferResource},
-    context::{self, SoundContext},
+    context::SoundContext,
     engine::SoundEngine,
     futures::executor::block_on,
     hrtf::HrirSphere,
@@ -44,7 +44,7 @@ fn main() {
     let engine = SoundEngine::new().unwrap();
 
     let hrir_path = PathBuf::from("examples/data/IRC_1002_C.bin");
-    let hrir_sphere = HrirSphere::from_file(&hrir_path, context::SAMPLE_RATE).unwrap();
+    let hrir_sphere = HrirSphere::from_file(&hrir_path, engine.sample_rate()).unwrap();
 
     // Initialize new sound context with default output device.
     let context = SoundContext::new();
@@ -55,6 +55,7 @@ fn main() {
     context
         .state()
         .set_renderer(Renderer::HrtfRenderer(HrtfRenderer::new(
+            engine.sample_rate(),
             HrirSphereResource::from_hrir_sphere(hrir_sphere, ResourceKind::External),
         )));
 

fyrox-sound/examples/reverb.rs

@@ -25,7 +25,7 @@ use fyrox_sound::renderer::hrtf::{HrirSphereResource, HrirSphereResourceExt};
 use fyrox_sound::{
     algebra::{Point3, UnitQuaternion, Vector3},
     buffer::{DataSource, SoundBufferResource},
-    context::{self, SoundContext},
+    context::SoundContext,
     effects::{reverb::Reverb, Effect},
     engine::SoundEngine,
     futures::executor::block_on,
@@ -40,12 +40,12 @@ use std::{
 };
 
 fn main() {
-    let hrir_path = PathBuf::from("examples/data/IRC_1002_C.bin");
-    let hrir_sphere = HrirSphere::from_file(&hrir_path, context::SAMPLE_RATE).unwrap();
-
     // Initialize sound engine with default output device.
     let engine = SoundEngine::new().unwrap();
 
+    let hrir_path = PathBuf::from("examples/data/IRC_1002_C.bin");
+    let hrir_sphere = HrirSphere::from_file(&hrir_path, engine.sample_rate()).unwrap();
+
     // Initialize new sound context.
     let context = SoundContext::new();
 
@@ -55,6 +55,7 @@ fn main() {
     context
         .state()
         .set_renderer(Renderer::HrtfRenderer(HrtfRenderer::new(
+            engine.sample_rate(),
             HrirSphereResource::from_hrir_sphere(hrir_sphere, ResourceKind::External),
         )));
 

fyrox-sound/examples/write_wav.rs

@@ -64,7 +64,7 @@ fn main() {
     // Create output wav file. The sample rate is currently fixed.
     let wav_spec = hound::WavSpec {
         channels: 2,
-        sample_rate: fyrox_sound::context::SAMPLE_RATE,
+        sample_rate: engine.sample_rate(),
         bits_per_sample: 32,
         sample_format: hound::SampleFormat::Float,
     };
@@ -76,7 +76,7 @@ fn main() {
     let mut samples_written = 0;
 
     // Wait until sound will play completely.
-    while samples_written < 3 * fyrox_sound::context::SAMPLE_RATE {
+    while samples_written < 3 * engine.sample_rate() {
         engine.state().render(&mut buf);
         for &(l, r) in buf.iter() {
             wav_writer.write_sample(l).unwrap();

fyrox-sound/output.wav

@@ -185,11 +185,11 @@ impl AudioBus {
         }
     }
 
-    fn apply_effects(&mut self) {
+    fn apply_effects(&mut self, sample_rate: u32) {
         // Pass through the chain of effects.
         for effect in self.effects.iter_mut() {
             let (input, output) = self.ping_pong_buffer.input_output_buffers();
-            effect.render(input, output);
+            effect.render(sample_rate, input, output);
             self.ping_pong_buffer.swap();
         }
     }
@@ -487,10 +487,10 @@ impl AudioBusGraph {
         }
     }
 
-    pub(crate) fn end_render(&mut self, output_device_buffer: &mut [(f32, f32)]) {
+    pub(crate) fn end_render(&mut self, sample_rate: u32, output_device_buffer: &mut [(f32, f32)]) {
         let mut leafs = Vec::new();
         for (handle, bus) in self.buses.pair_iter_mut() {
-            bus.apply_effects();
+            bus.apply_effects(sample_rate);
 
             if bus.child_buses.is_empty() {
                 leafs.push(handle);
@@ -531,6 +531,8 @@ mod test {
         effects::{Attenuate, Effect},
     };
 
+    const SAMPLE_RATE: u32 = 44100;
+
     #[test]
     fn test_multi_bus_data_flow() {
         let mut output_buffer = [(0.0f32, 0.0f32)];
@@ -553,7 +555,7 @@ mod test {
             *right = 1.0;
         }
 
-        graph.end_render(&mut output_buffer);
+        graph.end_render(SAMPLE_RATE, &mut output_buffer);
 
         assert_eq!(output_buffer[0], (2.0, 2.0));
     }
@@ -572,7 +574,7 @@ mod test {
             *right = 1.0;
         }
 
-        graph.end_render(&mut output_buffer);
+        graph.end_render(SAMPLE_RATE, &mut output_buffer);
 
         assert_eq!(output_buffer[0], (1.0, 1.0));
     }
@@ -606,7 +608,7 @@ mod test {
             *right = 1.0;
         }
 
-        graph.end_render(&mut output_buffer);
+        graph.end_render(SAMPLE_RATE, &mut output_buffer);
 
         assert_eq!(output_buffer[0], (0.75, 0.75));
     }

fyrox-sound/src/bus.rs

@@ -51,10 +51,6 @@ use std::{
 };
 use strum_macros::{AsRefStr, EnumString, VariantNames};
 
-/// Sample rate for output device.
-/// TODO: Make this configurable, for now its set to most commonly used sample rate of 44100 Hz.
-pub const SAMPLE_RATE: u32 = 44100;
-
 /// Distance model defines how volume of sound will decay when distance to listener changes.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Reflect, Visit, AsRefStr, EnumString, VariantNames)]
 #[repr(u32)]
@@ -186,12 +182,6 @@ impl State {
         self.distance_model
     }
 
-    /// Normalizes given frequency using context's sampling rate. Normalized frequency then can be used
-    /// to create filters.
-    pub fn normalize_frequency(&self, f: f32) -> f32 {
-        f / SAMPLE_RATE as f32
-    }
-
     /// Returns amount of time context spent on rendering all sound sources.
     pub fn full_render_duration(&self) -> Duration {
         self.render_duration
@@ -275,7 +265,7 @@ impl State {
         &mut self.bus_graph
     }
 
-    pub(crate) fn render(&mut self, output_device_buffer: &mut [(f32, f32)]) {
+    pub(crate) fn render(&mut self, sample_rate: u32, output_device_buffer: &mut [(f32, f32)]) {
         let last_time = fyrox_core::instant::Instant::now();
 
         if !self.paused {
@@ -294,7 +284,7 @@ impl State {
             {
                 if let Some(bus_input_buffer) = self.bus_graph.try_get_bus_input_buffer(&source.bus)
                 {
-                    source.render(output_device_buffer.len());
+                    source.render(sample_rate, output_device_buffer.len());
 
                     match self.renderer {
                         Renderer::Default => {
@@ -308,6 +298,7 @@ impl State {
                         }
                         Renderer::HrtfRenderer(ref mut hrtf_renderer) => {
                             hrtf_renderer.render_source(
+                                sample_rate,
                                 source,
                                 &self.listener,
                                 self.distance_model,
@@ -318,7 +309,7 @@ impl State {
                 }
             }
 
-            self.bus_graph.end_render(output_device_buffer);
+            self.bus_graph.end_render(sample_rate, output_device_buffer);
         }
 
         self.render_duration = fyrox_core::instant::Instant::now() - last_time;

fyrox-sound/src/context.rs

@@ -21,7 +21,6 @@
 //! Contains various filter effects. For example, lowpass filter could be used to muffle sounds.
 
 use crate::{
-    context::SAMPLE_RATE,
     dsp::{filters::Biquad, filters::BiquadKind},
     effects::EffectRenderTrait,
 };
@@ -44,6 +43,10 @@ macro_rules! define_filter_effect {
             #[reflect(setter = "set_quality")]
             quality: f32,
 
+            #[reflect(hidden)]
+            #[visit(skip)]
+            sample_rate: u32,
+
             #[reflect(hidden)]
             left: Biquad,
             #[reflect(hidden)]
@@ -52,20 +55,37 @@ macro_rules! define_filter_effect {
 
         impl Default for $name {
             fn default() -> Self {
-                let mut filter = Self {
+                Self {
                     cutoff_frequency_hz: 2200.0,
                     gain: 1.0,
                     quality: 0.5,
                     left: Default::default(),
                     right: Default::default(),
-                };
-                filter.update();
-                filter
+                    sample_rate: 0
+                }
             }
         }
 
         impl EffectRenderTrait for $name {
-            fn render(&mut self, input: &[(f32, f32)], output: &mut [(f32, f32)]) {
+            fn render(&mut self, sample_rate: u32, input: &[(f32, f32)], output: &mut [(f32, f32)]) {
+                if self.sample_rate != sample_rate {
+                    self.sample_rate = sample_rate;
+
+                    self.left.tune(
+                        $kind,
+                        self.cutoff_frequency_hz / self.sample_rate as f32,
+                        self.gain,
+                        self.quality
+                    );
+
+                    self.right.tune(
+                        $kind,
+                        self.cutoff_frequency_hz / self.sample_rate as f32,
+                        self.gain,
+                        self.quality
+                    );
+                }
+
                 for ((input_left, input_right), (output_left, output_right)) in input.iter().zip(output) {
                     *output_left = self.left.feed(*input_left);
                     *output_right = self.right.feed(*input_right);
@@ -78,7 +98,7 @@ macro_rules! define_filter_effect {
             #[inline]
             pub fn set_gain(&mut self, gain: f32) {
                 self.gain = gain;
-                self.update();
+                self.sample_rate = 0;
             }
 
             /// Returns filter's gain coefficient.
@@ -92,7 +112,7 @@ macro_rules! define_filter_effect {
             #[inline]
             pub fn set_cutoff_frequency_hz(&mut self, freq: f32) {
                 self.cutoff_frequency_hz = freq;
-                self.update();
+                self.sample_rate = 0;
             }
 
             /// Returns a cutoff frequency of the filter in Hertz.
@@ -106,30 +126,14 @@ macro_rules! define_filter_effect {
             #[inline]
             pub fn set_quality(&mut self, quality: f32) {
                 self.quality = quality;
-                self.update();
+                self.sample_rate = 0;
             }
 
             /// Returns the quality of the filter.
             #[inline]
             pub fn quality(&self) -> f32 {
                 self.quality
             }
-
-            fn update(&mut self) {
-                self.left.tune(
-                    $kind,
-                    self.cutoff_frequency_hz / SAMPLE_RATE as f32,
-                    self.gain,
-                    self.quality
-                );
-
-                self.right.tune(
-                    $kind,
-                    self.cutoff_frequency_hz / SAMPLE_RATE as f32,
-                    self.gain,
-                    self.quality
-                )
-            }
         }
     };
 }