alex/nih-plug
1
0
Fork 0
Code Activity

Move plugin descriptor to its own module

Browse source 
Because we also need this in the clap_plugin implementation.
This commit is contained in:
Robbert van der Helm 2022-02-28 18:44:03 +01:00
parent 32a640acf7
commit 2e6faaa324
3 changed files with 108 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/wrapper/clap.rs
View file

@ -1,3 +1,4 @@
mod descriptor;
mod factory;
mod plugin;

98
src/wrapper/clap/descriptor.rs Normal file
View file

@ -0,0 +1,98 @@
use clap_sys::plugin::clap_plugin_descriptor;
use clap_sys::version::CLAP_VERSION;
use std::ffi::{CStr, CString};
use std::marker::PhantomData;
use std::mem::MaybeUninit;
use std::os::raw::c_char;
use std::ptr;
use crate::plugin::ClapPlugin;
/// A static descriptor for a plugin. This is used in both the descriptor and on the plugin object
/// itself.
///
/// This cannot be cloned as [Self::clap_features_ptrs] contains pointers to [Self::clap_features].
pub struct PluginDescriptor<P: ClapPlugin> {
// We need [CString]s for all of `ClapPlugin`'s `&str` fields
clap_id: CString,
name: CString,
vendor: CString,
url: CString,
clap_manual_url: CString,
clap_support_url: CString,
version: CString,
clap_description: CString,
clap_features: Vec<CString>,
clap_features_ptrs: MaybeUninit<Vec<*const c_char>>,
/// We only support a single plugin per descriptor right now, so we'll fill in the plugin
/// descriptor upfront. We also need to initialize the `CString` fields above first before we
/// can initialize this plugin descriptor.
plugin_descriptor: MaybeUninit<clap_plugin_descriptor>,
/// The plugin's type.
_phantom: PhantomData<P>,
}
impl<P: ClapPlugin> Default for PluginDescriptor<P> {
fn default() -> Self {
let mut descriptor = Self {
clap_id: CString::new(P::CLAP_ID).expect("`CLAP_ID` contained null bytes"),
name: CString::new(P::NAME).expect("`NAME` contained null bytes"),
vendor: CString::new(P::VENDOR).expect("`VENDOR` contained null bytes"),
url: CString::new(P::URL).expect("`URL` contained null bytes"),
clap_manual_url: CString::new(P::CLAP_MANUAL_URL)
.expect("`CLAP_MANUAL_URL` contained null bytes"),
clap_support_url: CString::new(P::CLAP_SUPPORT_URL)
.expect("`CLAP_SUPPORT_URL` contained null bytes"),
version: CString::new(P::VERSION).expect("`VERSION` contained null bytes"),
clap_description: CString::new(P::CLAP_DESCRIPTION)
.expect("`CLAP_DESCRIPTION` contained null bytes"),
clap_features: P::CLAP_FEATURES
.iter()
.map(|s| CString::new(*s).expect("`CLAP_FEATURES` contained null bytes"))
.collect(),
clap_features_ptrs: MaybeUninit::uninit(),
plugin_descriptor: MaybeUninit::uninit(),
_phantom: PhantomData,
};
// The keyword list is an environ-like list of char pointers terminated by a null pointer
let mut clap_features_ptrs: Vec<*const c_char> = descriptor
.clap_features
.iter()
.map(|feature| feature.as_ptr())
.collect();
clap_features_ptrs.push(ptr::null());
descriptor.clap_features_ptrs.write(clap_features_ptrs);
// We couldn't initialize this directly because of all the CStrings
descriptor.plugin_descriptor.write(clap_plugin_descriptor {
clap_version: CLAP_VERSION,
id: descriptor.clap_id.as_ptr(),
name: descriptor.name.as_ptr(),
vendor: descriptor.vendor.as_ptr(),
url: descriptor.url.as_ptr(),
manual_url: descriptor.clap_manual_url.as_ptr(),
support_url: descriptor.clap_support_url.as_ptr(),
version: descriptor.version.as_ptr(),
description: descriptor.clap_description.as_ptr(),
features: unsafe { descriptor.clap_features_ptrs.assume_init_ref() }.as_ptr(),
});
descriptor
}
}
unsafe impl<P: ClapPlugin> Send for PluginDescriptor<P> {}
unsafe impl<P: ClapPlugin> Sync for PluginDescriptor<P> {}
impl<P: ClapPlugin> PluginDescriptor<P> {
pub fn clap_plugin_descriptor(&self) -> &clap_plugin_descriptor {
unsafe { self.plugin_descriptor.assume_init_ref() }
}
pub fn clap_id(&self) -> &CStr {
self.clap_id.as_c_str()
}
}

89
src/wrapper/clap/factory.rs
View file

@ -1,13 +1,11 @@
use clap_sys::host::clap_host;
use clap_sys::plugin::{clap_plugin, clap_plugin_descriptor};
use clap_sys::plugin_factory::clap_plugin_factory;
use clap_sys::version::CLAP_VERSION;
use std::ffi::{CStr, CString};
use std::marker::PhantomData;
use std::mem::MaybeUninit;
use std::ffi::CStr;
use std::os::raw::c_char;
use std::ptr;
use super::descriptor::PluginDescriptor;
use super::plugin::Plugin;
use crate::ClapPlugin;
@ -19,92 +17,22 @@ pub struct Factory<P: ClapPlugin> {
// Keep the vtable as the first field so we can do a simple pointer cast
pub clap_plugin_factory: clap_plugin_factory,
// We need [CString]s for all of `ClapPlugin`'s `&str` fields
clap_id: CString,
name: CString,
vendor: CString,
url: CString,
clap_manual_url: CString,
clap_support_url: CString,
version: CString,
clap_description: CString,
clap_features: Vec<CString>,
clap_features_ptrs: MaybeUninit<CStrPtrs>,
/// We only support a single plugin per factory right now, so we'll fill in the plugin
/// descriptor upfront. We also need to initialize the `CString` fields above first before we
/// can initialize this plugin descriptor.
plugin_descriptor: MaybeUninit<clap_plugin_descriptor>,
/// The type will be used for constructing plugin instances later.
_phantom: PhantomData<P>,
plugin_descriptor: PluginDescriptor<P>,
}
/// Needed for the Send+Sync implementation for lazy_static.
struct CStrPtrs(Vec<*const c_char>);
impl<P: ClapPlugin> Default for Factory<P> {
fn default() -> Self {
let mut factory = Self {
Self {
clap_plugin_factory: clap_plugin_factory {
get_plugin_count: Self::get_plugin_count,
get_plugin_descriptor: Self::get_plugin_descriptor,
create_plugin: Self::create_plugin,
},
clap_id: CString::new(P::CLAP_ID).expect("`CLAP_ID` contained null bytes"),
name: CString::new(P::NAME).expect("`NAME` contained null bytes"),
vendor: CString::new(P::VENDOR).expect("`VENDOR` contained null bytes"),
url: CString::new(P::URL).expect("`URL` contained null bytes"),
clap_manual_url: CString::new(P::CLAP_MANUAL_URL)
.expect("`CLAP_MANUAL_URL` contained null bytes"),
clap_support_url: CString::new(P::CLAP_SUPPORT_URL)
.expect("`CLAP_SUPPORT_URL` contained null bytes"),
version: CString::new(P::VERSION).expect("`VERSION` contained null bytes"),
clap_description: CString::new(P::CLAP_DESCRIPTION)
.expect("`CLAP_DESCRIPTION` contained null bytes"),
clap_features: P::CLAP_FEATURES
.iter()
.map(|s| CString::new(*s).expect("`CLAP_FEATURES` contained null bytes"))
.collect(),
clap_features_ptrs: MaybeUninit::uninit(),
plugin_descriptor: MaybeUninit::uninit(),
_phantom: PhantomData,
};
// The keyword list is an environ-like list of char pointers terminated by a null pointer
let mut clap_features_ptrs: Vec<*const c_char> = factory
.clap_features
.iter()
.map(|feature| feature.as_ptr())
.collect();
clap_features_ptrs.push(ptr::null());
factory
.clap_features_ptrs
.write(CStrPtrs(clap_features_ptrs));
// We couldn't initialize this directly because of all the CStrings
factory.plugin_descriptor.write(clap_plugin_descriptor {
clap_version: CLAP_VERSION,
id: factory.clap_id.as_ptr(),
name: factory.name.as_ptr(),
vendor: factory.vendor.as_ptr(),
url: factory.url.as_ptr(),
manual_url: factory.clap_manual_url.as_ptr(),
support_url: factory.clap_support_url.as_ptr(),
version: factory.version.as_ptr(),
description: factory.clap_description.as_ptr(),
features: unsafe { factory.clap_features_ptrs.assume_init_ref() }
.0
.as_ptr(),
});
factory
plugin_descriptor: PluginDescriptor::default(),
}
}
}
unsafe impl Send for CStrPtrs {}
unsafe impl Sync for CStrPtrs {}
impl<P: ClapPlugin> Factory<P> {
unsafe extern "C" fn get_plugin_count(_factory: *const clap_plugin_factory) -> u32 {
1
@ -117,7 +45,7 @@ impl<P: ClapPlugin> Factory<P> {
let factory = &*(factory as *const Self);
if index == 0 {
factory.plugin_descriptor.assume_init_ref()
factory.plugin_descriptor.clap_plugin_descriptor()
} else {
ptr::null()
}
@ -130,7 +58,8 @@ impl<P: ClapPlugin> Factory<P> {
) -> *const clap_plugin {
let factory = &*(factory as *const Self);
if !plugin_id.is_null() && CStr::from_ptr(plugin_id) == factory.clap_id.as_c_str() {
if !plugin_id.is_null() && CStr::from_ptr(plugin_id) == factory.plugin_descriptor.clap_id()
{
&Box::leak(Box::new(Plugin::<P>::new(host))).clap_plugin
} else {
ptr::null()