engine: 0.2.1 - add master volume, fix memory safety issues

- Consumers of the sqa-engine library should upgrade.
- Bugfix: we now use Acquire & Release atomic orderings to ensure
  we don't deallocate a volume parameter in the middle of it being
  used.
- We now support a 'master volume' that is independent of a Sender's
  volume. Useful for multi-channel streams!
- We now clip audio properly.

Author: eeeeeta

sqa-engine/Cargo.toml

@@ -6,7 +6,7 @@ repository = "https://github.com/eeeeeta/sqa-engine"
 readme = "README.md"
 keywords = ["audio", "sqa"]
 license = "GPLv3"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["eeeeeta <eeeeeta@users.noreply.github.com>"]
 
 [dependencies]

sqa-engine/src/lib.rs

@@ -70,6 +70,8 @@ pub struct Sender<T> {
     output_patch: Arc<AtomicUsize>,
     /// The playback volume (rw)
     volume: Arc<AtomicPtr<Parameter<f32>>>,
+    /// The master playback volume (rw)
+    master_vol: Arc<AtomicPtr<Parameter<f32>>>,
     /// The buffer to write to (or not) - will be a `bounded_spsc_queue::Producer<f32>` or `()`.
     pub buf: T,
     /// The sample rate of this sender. Can differ from the output sample rate.
@@ -104,20 +106,39 @@ impl<T> Sender<T> {
         self.set_start_time(time);
         self.set_active(true);
     }
+    pub fn set_master_volume(&mut self, vol: Box<Parameter<f32>>) {
+        let val = Box::into_raw(vol);
+        let old_ptr = self.master_vol.swap(val, AcqRel);
+        unsafe {
+            let _: Box<Parameter<f32>> = Box::from_raw(old_ptr);
+        }
+    }
+    pub fn master_volume(&self) -> Parameter<f32> {
+        let ret;
+        unsafe {
+            let val = self.master_vol.load(Acquire);
+            ret = (*val).clone();
+            self.master_vol.store(val, Release);
+        }
+        ret
+    }
     /// Set the volume of this stream.
     pub fn set_volume(&mut self, vol: Box<Parameter<f32>>) {
         let val = Box::into_raw(vol);
-        let old_ptr = self.volume.swap(val, Relaxed);
+        let old_ptr = self.volume.swap(val, AcqRel);
         unsafe {
             let _: Box<Parameter<f32>> = Box::from_raw(old_ptr);
         }
     }
     /// Get the volume of this stream.
-    pub fn volume(&self) -> &Parameter<f32> {
-        let val = self.volume.load(Relaxed);
+    pub fn volume(&self) -> Parameter<f32> {
+        let ret;
         unsafe {
-            &*val
+            let val = self.volume.load(Acquire);
+            ret = (*val).clone();
+            self.volume.store(val, Release);
         }
+        ret
     }
     /// Get whether this stream will play samples or not.
     pub fn active(&self) -> bool {
@@ -174,6 +195,7 @@ impl<T> Sender<T> {
             start_time: self.start_time.clone(),
             output_patch: self.output_patch.clone(),
             volume: self.volume.clone(),
+            master_vol: self.master_vol.clone(),
             buf: (),
             sample_rate: self.sample_rate,
             original: false,
@@ -289,7 +311,9 @@ impl EngineContext {
         let position = Arc::new(AtomicU64::new(0));
         let start_time = Arc::new(AtomicU64::new(0));
         let default_volume = Box::new(Parameter::Raw(1.0));
+        let default_master_vol = default_volume.clone();
         let volume = Arc::new(AtomicPtr::new(Box::into_raw(default_volume)));
+        let master_vol = Arc::new(AtomicPtr::new(Box::into_raw(default_master_vol)));
         let output_patch = Arc::new(AtomicUsize::new(::std::usize::MAX));
         let uu = Uuid::new_v4();
 
@@ -302,6 +326,7 @@ impl EngineContext {
             alive: alive.clone(),
             output_patch: output_patch.clone(),
             volume: volume.clone(),
+            master_vol: master_vol.clone(),
             uuid: uu,
             half_sent: false,
             empty_sent: false
@@ -316,6 +341,7 @@ impl EngineContext {
             start_time: start_time,
             sample_rate: sample_rate,
             volume: volume.clone(),
+            master_vol: master_vol.clone(),
             original: true,
             uuid: uu
         }

sqa-engine/src/param.rs

@@ -14,7 +14,7 @@ pub struct FadeDetails<T> where T: Mul<f32, Output=T> + Sub<T, Output=T> + Add<T
     duration: Arc<AtomicU64>,
     active: Arc<AtomicBool>
 }
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum Parameter<T> where T: Mul<f32, Output=T> + Sub<T, Output=T> + Add<T, Output=T> + Copy + Display {
     Raw(T),
     LinearFade(FadeDetails<T>)

sqa-engine/src/thread.rs

@@ -23,6 +23,7 @@ pub struct Player {
     pub alive: Arc<AtomicBool>,
     pub output_patch: Arc<AtomicUsize>,
     pub volume: Arc<AtomicPtr<Parameter<f32>>>,
+    pub master_vol: Arc<AtomicPtr<Parameter<f32>>>,
     pub uuid: Uuid,
     pub half_sent: bool,
     pub empty_sent: bool
@@ -151,10 +152,16 @@ impl JackHandler for DeviceContext {
                 player.active.store(false, Relaxed);
                 continue;
             }
-            let vol = player.volume.load(Relaxed);
+            let volp = player.volume.load(Acquire);
+            let master_volp = player.master_vol.load(Acquire);
             let vol = unsafe {
-                (*vol).get(time)
+                (*volp).get(time)
             };
+            let master_vol = unsafe {
+                (*master_volp).get(time)
+            };
+            player.volume.store(volp, Release);
+            player.master_vol.store(master_volp, Release);
             let ch = self.chans[outpatch].as_mut().unwrap();
             if let Some(buf) = out.get_port_buffer(&ch.port) {
                 let written = time == ch.written_t;
@@ -164,11 +171,13 @@ impl JackHandler for DeviceContext {
                 for x in buf.iter_mut() {
                     if let Some(data) = player.buf.try_pop() {
                         if written {
-                            *x += data * vol;
+                            *x += data * vol * master_vol;
                         }
                         else {
-                            *x = data * vol;
+                            *x = data * vol * master_vol;
                         }
+                        if *x > 1.0 { *x = 1.0; }
+                        if *x < -1.0 { *x = -1.0; }
                         pos += 1;
                     }
                 }