refactor extensions a little; add Proxy helper

Author: Quant1um

Cargo.lock

@@ -41,6 +41,7 @@ textwrap = { version = "0.16.2", features = ["terminal_size"] }
 time = { version = "0.3", features = ["serde"]}
 walkdir = "2.3"
 wait-timeout = "0.2.1"
+rustc-hash = "2.1.1"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.10.1"

Cargo.toml

@@ -20,15 +20,13 @@ pub mod tail;
 pub mod thread_pool;
 pub mod voice_info;
 
-/// An abstraction for a CLAP plugin extension. `P` here is the plugin type. In practice, this is
-/// either `Plugin`, `PluginShared` or `PluginAudioThread`. Abstractions for main thread functions will implement
-/// this trait for `Plugin`, abstractions for audio thread functions will implement this trait
-/// for `PluginAudioThread` and abstractions for thread-safe functions will implement this trait for
-/// `PluginShared`.
-pub trait Extension<P> {
+/// An abstraction for a CLAP plugin extension.
+pub trait Extension {
     /// The list of C-string IDs for the extension.
     const IDS: &'static [&'static CStr];
 
+    /// The plugin type (`Plugin` for main-thread, `PluginShared` for shared, `PluginAudioThread` for audio-thread) for which this extension is implemented.
+    type Plugin;
     /// The type of the C-struct for the extension.
     type Struct;
 
@@ -38,5 +36,5 @@ pub trait Extension<P> {
     /// # Safety
     /// The extension struct pointer must be a valid pointer to the correct extension struct for
     /// the plugin instance and given `IDS`.
-    unsafe fn new(plugin: P, extension_struct: NonNull<Self::Struct>) -> Self;
+    unsafe fn new(plugin: Self::Plugin, extension_struct: NonNull<Self::Struct>) -> Self;
 }

src/plugin/ext.rs

@@ -11,9 +11,10 @@ pub struct Ambisonic<'a> {
     ambisonic: NonNull<clap_plugin_ambisonic>,
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for Ambisonic<'a> {
+impl<'a> Extension for Ambisonic<'a> {
     const IDS: &'static [&'static CStr] = &[CLAP_EXT_AMBISONIC, CLAP_EXT_AMBISONIC_COMPAT];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_ambisonic;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {

src/plugin/ext/ambisonic.rs

@@ -48,14 +48,18 @@ pub struct AudioPort {
     /// Supports 64 bit processing
     pub supports_double_sample_size: bool,
 
+    /// Prefers 64 bit processing
+    pub prefers_double_sample_size: bool,
+
     /// All ports with this flag require common sample size
     #[allow(unused)] // TODO: use for future mixed precision processing tests
     pub requires_common_sample_size: bool,
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for AudioPorts<'a> {
+impl<'a> Extension for AudioPorts<'a> {
     const IDS: &'static [&'static CStr] = &[CLAP_EXT_AUDIO_PORTS];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_audio_ports;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {
@@ -70,6 +74,20 @@ impl AudioPorts<'_> {
     /// Get the audio port configuration for this plugin. This automatically performs a number of
     /// consistency checks on the plugin's audio port configuration.
     pub fn config(&self) -> Result<AudioPortConfig> {
+        fn get_raw_port_info(this: &AudioPorts, is_input: bool, port_index: u32) -> Option<clap_audio_port_info> {
+            let audio_ports = this.audio_ports.as_ptr();
+            let plugin = this.plugin.as_ptr();
+
+            unsafe {
+                let mut info = clap_audio_port_info { ..zeroed() };
+                if !clap_call! { audio_ports=>get(plugin, port_index, is_input, &mut info) } {
+                    return None;
+                }
+
+                Some(info)
+            }
+        }
+
         let mut config = AudioPortConfig::default();
 
         let audio_ports = self.audio_ports.as_ptr();
@@ -82,12 +100,12 @@ impl AudioPorts<'_> {
         };
 
         for index in 0..num_inputs {
-            let info = match self.get_raw_port_info(true, index) {
+            let info = match get_raw_port_info(self, true, index) {
                 Some(info) => info,
                 None => {
                     anyhow::bail!(
                         "Plugin returned false when querying audio port info for input port {index} (out of \
-                         {num_inputs} total)."
+                         {num_inputs} total)"
                     );
                 }
             };
@@ -99,12 +117,12 @@ impl AudioPorts<'_> {
         }
 
         for index in 0..num_outputs {
-            let info = match self.get_raw_port_info(false, index) {
+            let info = match get_raw_port_info(self, false, index) {
                 Some(info) => info,
                 None => {
                     anyhow::bail!(
                         "Plugin returned false when querying audio port info for output port {index} (out of \
-                         {num_outputs} total)."
+                         {num_outputs} total)"
                     );
                 }
             };
@@ -155,22 +173,6 @@ impl AudioPorts<'_> {
 
         Ok(config)
     }
-
-    /// Get the raw audio port information for the given port index. This does not perform any
-    /// consistency checks.
-    pub fn get_raw_port_info(&self, is_input: bool, port_index: u32) -> Option<clap_audio_port_info> {
-        let audio_ports = self.audio_ports.as_ptr();
-        let plugin = self.plugin.as_ptr();
-
-        unsafe {
-            let mut info = clap_audio_port_info { ..zeroed() };
-            if !clap_call! { audio_ports=>get(plugin, port_index, is_input, &mut info) } {
-                return None;
-            }
-
-            Some(info)
-        }
-    }
 }
 
 pub fn check_audio_port_info_valid(
@@ -228,6 +230,7 @@ pub fn check_audio_port_info_valid(
 
         supports_double_sample_size,
         requires_common_sample_size,
+        prefers_double_sample_size,
     })
 }
 

src/plugin/ext/audio_ports.rs

@@ -11,9 +11,10 @@ pub struct AudioPortsActivation<'a> {
     audio_ports_activation: NonNull<clap_plugin_audio_ports_activation>,
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for AudioPortsActivation<'a> {
+impl<'a> Extension for AudioPortsActivation<'a> {
     const IDS: &'static [&'static CStr] = &[CLAP_EXT_AUDIO_PORTS_ACTIVATION, CLAP_EXT_AUDIO_PORTS_ACTIVATION_COMPAT];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_audio_ports_activation;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {

src/plugin/ext/audio_ports_activation.rs

@@ -1,6 +1,6 @@
 use crate::plugin::ext::Extension;
 use crate::plugin::ext::ambisonic::Ambisonic;
-use crate::plugin::ext::audio_ports::check_audio_port_type_consistent;
+use crate::plugin::ext::audio_ports::{AudioPort, check_audio_port_info_valid, check_audio_port_type_consistent};
 use crate::plugin::ext::surround::Surround;
 use crate::plugin::instance::Plugin;
 use crate::plugin::util::{c_char_slice_to_string, clap_call};
@@ -35,9 +35,10 @@ pub struct AudioPortsConfigConfig {
     pub main_output_channel_count: Option<u32>,
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for AudioPortsConfig<'a> {
+impl<'a> Extension for AudioPortsConfig<'a> {
     const IDS: &'static [&'static CStr] = &[CLAP_EXT_AUDIO_PORTS_CONFIG];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_audio_ports_config;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {
@@ -48,12 +49,13 @@ impl<'a> Extension<&'a Plugin<'a>> for AudioPortsConfig<'a> {
     }
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for AudioPortsConfigInfo<'a> {
+impl<'a> Extension for AudioPortsConfigInfo<'a> {
     const IDS: &'static [&'static CStr] = &[
         CLAP_EXT_AUDIO_PORTS_CONFIG_INFO,
         CLAP_EXT_AUDIO_PORTS_CONFIG_INFO_COMPAT,
     ];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_audio_ports_config_info;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {
@@ -147,6 +149,7 @@ impl AudioPortsConfig<'_> {
 }
 
 impl AudioPortsConfigInfo<'_> {
+    /// Get the current selected audio ports configuration ID.
     pub fn current(&self) -> clap_id {
         let audio_ports_config_info = self.audio_ports_config_info.as_ptr();
         let plugin = self.plugin.as_ptr();
@@ -156,24 +159,20 @@ impl AudioPortsConfigInfo<'_> {
         }
     }
 
-    /// Get the raw audio port information for the given port index. This does not perform any
-    /// consistency checks.
-    pub fn get_raw_port_info(
-        &self,
-        config_id: clap_id,
-        is_input: bool,
-        port_index: u32,
-    ) -> Option<clap_audio_port_info> {
-        let audio_ports_config_info = self.audio_ports_config_info.as_ptr();
-        let plugin = self.plugin.as_ptr();
+    /// Get information about an audio port for a configuration.
+    pub fn get(&self, config_id: clap_id, is_input: bool, port_index: u32) -> Result<AudioPort> {
+        let info = unsafe {
+            let audio_ports_config_info = self.audio_ports_config_info.as_ptr();
+            let plugin = self.plugin.as_ptr();
 
-        unsafe {
             let mut info = clap_audio_port_info { ..zeroed() };
             if !clap_call! { audio_ports_config_info=>get(plugin, config_id, port_index, is_input, &mut info) } {
-                return None;
+                anyhow::bail!("audio_ports_config_info::get() returned false");
             }
 
-            Some(info)
-        }
+            info
+        };
+
+        check_audio_port_info_valid(self.plugin, is_input, port_index, &info)
     }
 }

src/plugin/ext/audio_ports_config.rs

@@ -43,12 +43,13 @@ pub struct ConfigurableAudioPorts<'a> {
     configurable_audio_ports: NonNull<clap_plugin_configurable_audio_ports>,
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for ConfigurableAudioPorts<'a> {
+impl<'a> Extension for ConfigurableAudioPorts<'a> {
     const IDS: &'static [&'static CStr] = &[
         CLAP_EXT_CONFIGURABLE_AUDIO_PORTS,
         CLAP_EXT_CONFIGURABLE_AUDIO_PORTS_COMPAT,
     ];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_configurable_audio_ports;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {

src/plugin/ext/configurable_audio_ports.rs

@@ -11,9 +11,10 @@ pub struct Latency<'a> {
     latency: NonNull<clap_plugin_latency>,
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for Latency<'a> {
+impl<'a> Extension for Latency<'a> {
     const IDS: &'static [&'static CStr] = &[CLAP_EXT_LATENCY];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_latency;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {

src/plugin/ext/latency.rs

@@ -34,9 +34,10 @@ pub struct NotePort {
     pub supported_dialects: Vec<clap_note_dialect>,
 }
 
-impl<'a> Extension<&'a Plugin<'a>> for NotePorts<'a> {
+impl<'a> Extension for NotePorts<'a> {
     const IDS: &'static [&'static CStr] = &[CLAP_EXT_NOTE_PORTS];
 
+    type Plugin = &'a Plugin<'a>;
     type Struct = clap_plugin_note_ports;
 
     unsafe fn new(plugin: &'a Plugin<'a>, extension_struct: NonNull<Self::Struct>) -> Self {