collect crates/ and deps/

crates/plugin/vst/examples/transfer_and_smooth.rs

@@ -0,0 +1,136 @@
+// This example illustrates how an existing plugin can be ported to the new,
+// thread-safe API with the help of the ParameterTransfer struct.
+// It shows how the parameter iteration feature of ParameterTransfer can be
+// used to react explicitly to parameter changes in an efficient way (here,
+// to implement smoothing of parameters).
+
+#[macro_use]
+extern crate vst;
+
+use std::f32;
+use std::sync::Arc;
+
+use vst::prelude::*;
+
+const PARAMETER_COUNT: usize = 100;
+const BASE_FREQUENCY: f32 = 5.0;
+const FILTER_FACTOR: f32 = 0.01; // Set this to 1.0 to disable smoothing.
+const TWO_PI: f32 = 2.0 * f32::consts::PI;
+
+// 1. Define a struct to hold parameters. Put a ParameterTransfer inside it,
+// plus optionally a HostCallback.
+struct MyPluginParameters {
+    #[allow(dead_code)]
+    host: HostCallback,
+    transfer: ParameterTransfer,
+}
+
+// 2. Put an Arc reference to your parameter struct in your main Plugin struct.
+struct MyPlugin {
+    params: Arc<MyPluginParameters>,
+    states: Vec<Smoothed>,
+    sample_rate: f32,
+    phase: f32,
+}
+
+// 3. Implement PluginParameters for your parameter struct.
+// The set_parameter and get_parameter just access the ParameterTransfer.
+// The other methods can be implemented on top of this as well.
+impl PluginParameters for MyPluginParameters {
+    fn set_parameter(&self, index: i32, value: f32) {
+        self.transfer.set_parameter(index as usize, value);
+    }
+
+    fn get_parameter(&self, index: i32) -> f32 {
+        self.transfer.get_parameter(index as usize)
+    }
+}
+
+impl Plugin for MyPlugin {
+    fn new(host: HostCallback) -> Self {
+        MyPlugin {
+            // 4. Initialize your main Plugin struct with a parameter struct
+            // wrapped in an Arc, and put the HostCallback inside it.
+            params: Arc::new(MyPluginParameters {
+                host,
+                transfer: ParameterTransfer::new(PARAMETER_COUNT),
+            }),
+            states: vec![Smoothed::default(); PARAMETER_COUNT],
+            sample_rate: 44100.0,
+            phase: 0.0,
+        }
+    }
+
+    fn get_info(&self) -> Info {
+        Info {
+            parameters: PARAMETER_COUNT as i32,
+            inputs: 0,
+            outputs: 2,
+            category: Category::Synth,
+            f64_precision: false,
+
+            name: "transfer_and_smooth".to_string(),
+            vendor: "Loonies".to_string(),
+            unique_id: 0x500007,
+            version: 100,
+
+            ..Info::default()
+        }
+    }
+
+    // 5. Return a reference to the parameter struct from get_parameter_object.
+    fn get_parameter_object(&mut self) -> Arc<dyn PluginParameters> {
+        Arc::clone(&self.params) as Arc<dyn PluginParameters>
+    }
+
+    fn set_sample_rate(&mut self, sample_rate: f32) {
+        self.sample_rate = sample_rate;
+    }
+
+    fn process(&mut self, buffer: &mut AudioBuffer<f32>) {
+        // 6. In the process method, iterate over changed parameters and do
+        // for each what you would previously do in set_parameter. Since this
+        // runs in the processing thread, it has mutable access to the Plugin.
+        for (p, value) in self.params.transfer.iterate(true) {
+            // Example: Update filter state of changed parameter.
+            self.states[p].set(value);
+        }
+
+        // Example: Dummy synth adding together a bunch of sines.
+        let samples = buffer.samples();
+        let mut outputs = buffer.split().1;
+        for i in 0..samples {
+            let mut sum = 0.0;
+            for p in 0..PARAMETER_COUNT {
+                let amp = self.states[p].get();
+                if amp != 0.0 {
+                    sum += (self.phase * p as f32 * TWO_PI).sin() * amp;
+                }
+            }
+            outputs[0][i] = sum;
+            outputs[1][i] = sum;
+            self.phase = (self.phase + BASE_FREQUENCY / self.sample_rate).fract();
+        }
+    }
+}
+
+// Example: Parameter smoothing as an example of non-trivial parameter handling
+// that has to happen when a parameter changes.
+#[derive(Clone, Default)]
+struct Smoothed {
+    state: f32,
+    target: f32,
+}
+
+impl Smoothed {
+    fn set(&mut self, value: f32) {
+        self.target = value;
+    }
+
+    fn get(&mut self) -> f32 {
+        self.state += (self.target - self.state) * FILTER_FACTOR;
+        self.state
+    }
+}
+
+plugin_main!(MyPlugin);