latency

1 files changed, 37 insertions, 12 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 82c1957..9f73aa9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,7 +3,13 @@ use crate::{
     gui::RetainPluginGui,
     params::{RetainParamsLocal, RetainParamsShared},
 };
-use clack_extensions::{audio_ports::*, gui::PluginGui, params::*, state::PluginState};
+use clack_extensions::{
+    audio_ports::*,
+    gui::PluginGui,
+    latency::{PluginLatency, PluginLatencyImpl},
+    params::*,
+    state::PluginState,
+};
 use clack_plugin::prelude::*;
 use std::sync::Arc;
 
@@ -19,7 +25,7 @@ pub struct RetainPlugin;
 
 impl Plugin for RetainPlugin {
     type AudioProcessor<'a> = RetainPluginAudioProcessor<'a>;
-    type Shared<'a> = RetainPluginShared;
+    type Shared<'a> = RetainPluginShared<'a>;
     type MainThread<'a> = RetainPluginMainThread<'a>;
 
     fn declare_extensions(
@@ -30,6 +36,7 @@ impl Plugin for RetainPlugin {
             .register::<PluginAudioPorts>()
             .register::<PluginParams>()
             .register::<PluginState>()
+            .register::<PluginLatency>()
             .register::<PluginGui>();
     }
 }
@@ -38,47 +45,59 @@ impl DefaultPluginFactory for RetainPlugin {
     fn get_descriptor() -> PluginDescriptor {
         use clack_plugin::plugin::features::*;
 
-        PluginDescriptor::new("org.haemolacriaa.retain", "Retain")
+        PluginDescriptor::new("com.haemolacriaa.retain", "Retain")
+            .with_description("Retains only the nth largest magnitude frequencies in the signal")
             .with_features([AUDIO_EFFECT, STEREO])
     }
 
-    fn new_shared(_host: HostSharedHandle<'_>) -> Result<Self::Shared<'_>, PluginError> {
-        Ok(RetainPluginShared {
-            params: Arc::new(RetainParamsShared::new()),
-        })
+    fn new_shared(host: HostSharedHandle<'_>) -> Result<Self::Shared<'_>, PluginError> {
+        Ok(RetainPluginShared::new(host))
     }
 
     fn new_main_thread<'a>(
-        _host: HostMainThreadHandle<'a>,
+        host: HostMainThreadHandle<'a>,
         shared: &'a Self::Shared<'a>,
     ) -> Result<Self::MainThread<'a>, PluginError> {
         Ok(Self::MainThread {
             shared,
             params: RetainParamsLocal::new(&shared.params),
+            host_main_thread: host,
             gui: None,
         })
     }
 }
 
 /// The plugin data that gets shared between the Main Thread and the Audio Thread.
-pub struct RetainPluginShared {
+pub struct RetainPluginShared<'a> {
     /// The plugin's parameter values.
     params: Arc<RetainParamsShared>,
+    /// A handle to the host
+    host: HostSharedHandle<'a>,
 }
 
-impl PluginShared<'_> for RetainPluginShared {}
+impl<'a> RetainPluginShared<'a> {
+    fn new(host: HostSharedHandle<'a>) -> Self {
+        RetainPluginShared {
+            params: Arc::new(RetainParamsShared::new()),
+            host: host,
+        }
+    }
+}
+
+impl<'a> PluginShared<'a> for RetainPluginShared<'a> {}
 
 /// The data that belongs to the main thread of our plugin.
 pub struct RetainPluginMainThread<'a> {
     /// The local state of the parameters
     params: RetainParamsLocal,
     /// A reference to the plugin's shared data.
-    shared: &'a RetainPluginShared,
+    shared: &'a RetainPluginShared<'a>,
+    host_main_thread: HostMainThreadHandle<'a>,
     /// The plugin's GUI state and context
     gui: Option<RetainPluginGui>,
 }
 
-impl<'a> PluginMainThread<'a, RetainPluginShared> for RetainPluginMainThread<'a> {
+impl<'a> PluginMainThread<'a, RetainPluginShared<'a>> for RetainPluginMainThread<'a> {
     fn on_main_thread(&mut self) {
         if let Some(gui) = &self.gui {
             gui.request_repaint();
@@ -86,4 +105,10 @@ impl<'a> PluginMainThread<'a, RetainPluginShared> for RetainPluginMainThread<'a>
     }
 }
 
+impl PluginLatencyImpl for RetainPluginMainThread<'_> {
+    fn get(&mut self) -> u32 {
+        self.params.get_window_size() as u32
+    }
+}
+
 clack_export_entry!(SinglePluginEntry<RetainPlugin>);