Split plugin API to make it thread safe. #49

Cargo.toml

@@ -26,6 +26,8 @@ documentation = "https://rust-dsp.github.io/rust-vst/vst/"
 license = "MIT"
 keywords = ["vst", "vst2", "plugin"]
 
+autoexamples = false
+
 [dependencies]
 log = "0.4"
 num-traits = "0.2"
@@ -56,3 +58,7 @@ crate-type = ["cdylib"]
 [[example]]
 name = "gain_effect"
 crate-type = ["cdylib"]
+
+[[example]]
+name = "transfer_and_smooth"
+crate-type = ["cdylib"]

examples/dimension_expander.rs

@@ -4,12 +4,13 @@
 extern crate vst;
 extern crate time;
 
-use vst::plugin::{Category, Info, Plugin};
 use vst::buffer::AudioBuffer;
+use vst::plugin::{Category, Info, Plugin, PluginParameters};
+use vst::util::AtomicFloat;
 
-use std::mem;
-use std::f64::consts::PI;
 use std::collections::VecDeque;
+use std::f64::consts::PI;
+use std::sync::Arc;
 
 /// Calculate the length in samples for a delay. Size ranges from 0.0 to 1.0.
 fn delay(index: usize, mut size: f32) -> isize {
@@ -34,8 +35,13 @@ type SamplePair = (f32, f32);
 /// The Dimension Expander.
 struct DimensionExpander {
     buffers: Vec<VecDeque<SamplePair>>,
-    dry_wet: f32,
-    size: f32,
+    params: Arc<DimensionExpanderParameters>,
+    old_size: f32,
+}
+
+struct DimensionExpanderParameters {
+    dry_wet: AtomicFloat,
+    size: AtomicFloat,
 }
 
 impl Default for DimensionExpander {
@@ -65,14 +71,17 @@ impl DimensionExpander {
 
         DimensionExpander {
             buffers: buffers,
-            dry_wet: dry_wet,
-            size: size,
+            params: Arc::new(DimensionExpanderParameters {
+                dry_wet: AtomicFloat::new(dry_wet),
+                size: AtomicFloat::new(size),
+            }),
+            old_size: size,
         }
     }
 
     /// Update the delay buffers with a new size value.
     fn resize(&mut self, n: f32) {
-        let old_size = mem::replace(&mut self.size, n);
+        let old_size = self.old_size;
 
         for (i, buffer) in self.buffers.iter_mut().enumerate() {
             // Calculate the size difference between delays
@@ -92,6 +101,8 @@ impl DimensionExpander {
                 }
             }
         }
+
+        self.old_size = n;
     }
 }
 
@@ -111,37 +122,6 @@ impl Plugin for DimensionExpander {
         }
     }
 
-    fn get_parameter(&self, index: i32) -> f32 {
-        match index {
-            0 => self.size,
-            1 => self.dry_wet,
-            _ => 0.0,
-        }
-    }
-
-    fn get_parameter_text(&self, index: i32) -> String {
-        match index {
-            0 => format!("{}", (self.size * 1000.0) as isize),
-            1 => format!("{:.1}%", self.dry_wet * 100.0),
-            _ => "".to_string(),
-        }
-    }
-
-    fn get_parameter_name(&self, index: i32) -> String {
-        match index {
-            0 => "Size",
-            1 => "Dry/Wet",
-            _ => "",
-        }.to_string()
-    }
-
-    fn set_parameter(&mut self, index: i32, val: f32) {
-        match index {
-            0 => self.resize(val),
-            1 => self.dry_wet = val,
-            _ => (),
-        }
-    }
     fn process(&mut self, buffer: &mut AudioBuffer<f32>) {
         let (inputs, mut outputs) = buffer.split();
 
@@ -150,6 +130,12 @@ impl Plugin for DimensionExpander {
             return;
         }
 
+        // Resize if size changed
+        let size = self.params.size.get();
+        if size != self.old_size {
+            self.resize(size);
+        }
+
         // Iterate over inputs as (&f32, &f32)
         let (l, r) = inputs.split_at(1);
         let stereo_in = l[0].iter().zip(r[0].iter());
@@ -182,7 +168,7 @@ impl Plugin for DimensionExpander {
                     // Sine wave volume LFO
                     let lfo = ((time_s * LFO_FREQ + offset) * PI * 2.0).sin() as f32;
 
-                    let wet = self.dry_wet * WET_MULT;
+                    let wet = self.params.dry_wet.get() * WET_MULT;
                     let mono = (left_old + right_old) / 2.0;
 
                     // Flip right channel and keep left mono so that the result is
@@ -197,6 +183,44 @@ impl Plugin for DimensionExpander {
             *right_out = *right_in + right_processed;
         }
     }
+
+    fn get_parameter_object(&mut self) -> Arc<PluginParameters> {
+        Arc::clone(&self.params) as Arc<PluginParameters>
+    }
+}
+
+impl PluginParameters for DimensionExpanderParameters {
+    fn get_parameter(&self, index: i32) -> f32 {
+        match index {
+            0 => self.size.get(),
+            1 => self.dry_wet.get(),
+            _ => 0.0,
+        }
+    }
+
+    fn get_parameter_text(&self, index: i32) -> String {
+        match index {
+            0 => format!("{}", (self.size.get() * 1000.0) as isize),
+            1 => format!("{:.1}%", self.dry_wet.get() * 100.0),
+            _ => "".to_string(),
+        }
+    }
+
+    fn get_parameter_name(&self, index: i32) -> String {
+        match index {
+            0 => "Size",
+            1 => "Dry/Wet",
+            _ => "",
+        }.to_string()
+    }
+
+    fn set_parameter(&self, index: i32, val: f32) {
+        match index {
+            0 => self.size.set(val),
+            1 => self.dry_wet.set(val),
+            _ => (),
+        }
+    }
 }
 
 plugin_main!(DimensionExpander);

examples/gain_effect.rs

@@ -5,16 +5,32 @@ extern crate vst;
 extern crate time;
 
 use vst::buffer::AudioBuffer;
-use vst::plugin::{Category, Info, Plugin};
+use vst::plugin::{Category, Info, Plugin, PluginParameters};
+use vst::util::AtomicFloat;
+
+use std::sync::Arc;
 
 /// Simple Gain Effect.
 /// Note that this does not use a proper scale for sound and shouldn't be used in
 /// a production amplification effect!  This is purely for demonstration purposes,
 /// as well as to keep things simple as this is meant to be a starting point for
 /// any effect.
 struct GainEffect {
-    // Here, we can store a variable that keeps track of the plugin's state.
-    amplitude: f32,
+    // Store a handle to the plugin's parameter object.
+    params: Arc<GainEffectParameters>,
+}
+
+/// The plugin's parameter object contains the values of parameters that can be
+/// adjusted from the host.  If we were creating an effect that didn't allow the
+/// user to modify it at runtime or have any controls, we could omit this part.
+///
+/// The parameters object is shared between the processing and GUI threads.
+/// For this reason, all mutable state in the object has to be represented
+/// through thread-safe interior mutability. The easiest way to achieve this
+/// is to store the parameters in atomic containers.
+struct GainEffectParameters {
+    // The plugin's state consists of a single parameter: amplitude.
+    amplitude: AtomicFloat,
 }
 
 // All plugins using the `vst` crate will either need to implement the `Default`
@@ -23,7 +39,13 @@ struct GainEffect {
 // 0.5 means it's halfway up.
 impl Default for GainEffect {
     fn default() -> GainEffect {
-        GainEffect { amplitude: 0.5f32 }
+        GainEffect { params: Arc::new(GainEffectParameters::default()) }
+    }
+}
+
+impl Default for GainEffectParameters {
+    fn default() -> GainEffectParameters {
+        GainEffectParameters { amplitude: AtomicFloat::new(0.5) }
     }
 }
 
@@ -46,20 +68,42 @@ impl Plugin for GainEffect {
         }
     }
 
-    // the `get_parameter` and `set_parameter` functions are required if we
-    // want to interact with the plugin.  If we were creating an effect that
-    // didn't allow the user to modify it at runtime or have any controls,
-    // we could omit these next parts.
+    // Here is where the bulk of our audio processing code goes.
+    fn process(&mut self, buffer: &mut AudioBuffer<f32>) {
+        // Read the amplitude from the parameter object
+        let amplitude = self.params.amplitude.get();
+        // First, we destructure our audio buffer into an arbitrary number of
+        // input and output buffers.  Usually, we'll be dealing with stereo (2 of each)
+        // but that might change.
+        for (input_buffer, output_buffer) in buffer.zip() {
+            // Next, we'll loop through each individual sample so we can apply the amplitude
+            // value to it.
+            for (input_sample, output_sample) in input_buffer.iter().zip(output_buffer) {
+                *output_sample = *input_sample * amplitude;
+            }
+        }
+    }
+
+    // Return the parameter object. This method can be omitted if the
+    // plugin has no parameters.
+    fn get_parameter_object(&mut self) -> Arc<PluginParameters> {
+        Arc::clone(&self.params) as Arc<PluginParameters>
+    }
+}
+
+impl PluginParameters for GainEffectParameters {
+    // the `get_parameter` function reads the value of a parameter.
     fn get_parameter(&self, index: i32) -> f32 {
         match index {
-            0 => self.amplitude,
+            0 => self.amplitude.get(),
             _ => 0.0,
         }
     }
 
-    fn set_parameter(&mut self, index: i32, val: f32) {
+    // the `set_parameter` function sets the value of a parameter.
+    fn set_parameter(&self, index: i32, val: f32) {
         match index {
-            0 => self.amplitude = val,
+            0 => self.amplitude.set(val),
             _ => (),
         }
     }
@@ -68,7 +112,7 @@ impl Plugin for GainEffect {
     // format it into a string that makes the most since.
     fn get_parameter_text(&self, index: i32) -> String {
         match index {
-            0 => format!("{:.2}", (self.amplitude - 0.5) * 2f32),
+            0 => format!("{:.2}", (self.amplitude.get() - 0.5) * 2f32),
             _ => "".to_string(),
         }
     }
@@ -80,20 +124,6 @@ impl Plugin for GainEffect {
             _ => "",
         }.to_string()
     }
-
-    // Here is where the bulk of our audio processing code goes.
-    fn process(&mut self, buffer: &mut AudioBuffer<f32>) {
-        // First, we destructure our audio buffer into an arbitrary number of
-        // input and output buffers.  Usually, we'll be dealing with stereo (2 of each)
-        // but that might change.
-        for (input_buffer, output_buffer) in buffer.zip() {
-            // Next, we'll loop through each individual sample so we can apply the amplitude
-            // value to it.
-            for (input_sample, output_sample) in input_buffer.iter().zip(output_buffer) {
-                *output_sample = *input_sample * self.amplitude;
-            }
-        }
-    }
 }
 
 // This part is important!  Without it, our plugin won't work.

examples/simple_host.rs

@@ -13,7 +13,7 @@ use vst::plugin::Plugin;
 struct SampleHost;
 
 impl Host for SampleHost {
-    fn automate(&mut self, index: i32, value: f32) {
+    fn automate(&self, index: i32, value: f32) {
         println!("Parameter {} had its value changed to {}", index, value);
     }
 }