Refactor API and Core to use raw pointers for plugin namespaces and IDs

- Updated `plugin_by_namespace` and `plugin_by_id` methods in `api.rs` to accept raw pointers instead of `&str`, removing the need for `CString`.
- Modified `CoreRef` methods to create `CString` from `&str` before passing to API functions.
- Enhanced `Node` and `FilterDependency` structs to support lifetimes, ensuring proper ownership semantics.
- Updated various methods in `CoreRef`, `Node`, and `Filter` traits to reflect changes in type signatures and improve safety.
- Added new methods in `CoreRef` for retrieving standard, resize, and text plugins.
- Adjusted tests to use `std::f64::consts::PI` instead of hardcoded values for better accuracy.

Author: animafps

example/src/lib.rs

@@ -18,23 +18,24 @@ mod plugin {
     const FLAGS: i32 = PluginConfigFlags::NONE.bits();
 
     #[vapoursynth_filter(video)]
-    struct Invert {
-        input_node: Node,
+    #[derive(Clone)]
+    struct Invert<'core> {
+        input_node: Node<'core>,
     }
 
     // Just implement the trait methods and the macro handles all C FFI
-    impl Filter for Invert {
+    impl<'core> Filter<'core> for Invert<'core> {
         const NAME: &'static str = "Invert";
         const ARGS: &'static str = "clip:vnode;";
         const RETURNTYPE: &'static str = "clip:vnode;";
         const MODE: FilterMode = FilterMode::Parallel;
 
-        fn from_args(args: &Map, _core: &CoreRef) -> Result<Self, String> {
+        fn from_args(args: &Map<'core>, _core: &CoreRef<'core>) -> Result<Self, String> {
             let input_node = args.get_node("clip")?;
             Ok(Self { input_node })
         }
 
-        fn get_dependencies(&self) -> Vec<FilterDependency> {
+        fn get_dependencies(&self) -> Vec<FilterDependency<'core>> {
             vec![FilterDependency {
                 source: self.input_node.clone(),
                 request_pattern: RequestPattern::StrictSpatial,
@@ -47,13 +48,13 @@ mod plugin {
                 .request_frame_filter(n, frame_ctx);
         }
 
-        fn process_frame<'core>(
+        fn process_frame<'frame>(
             &mut self,
             n: i32,
             _frame_data: &[u8; 4],
             frame_ctx: &FrameContext,
-            core: CoreRef<'core>,
-        ) -> Result<Frame<'core>, String> {
+            core: CoreRef<'frame>,
+        ) -> Result<Frame<'frame>, String> {
             let src = self.input_node.get_frame_filter(n, frame_ctx).unwrap();
             let vf = src.get_video_format().unwrap();
             let height = src.get_height(0);

rustsynth-derive/src/lib.rs

@@ -1,7 +1,7 @@
 //! Module for interacting with the VapourSynth API
 use rustsynth_sys as ffi;
 use std::{
-    ffi::{c_char, c_int, c_void, CString},
+    ffi::{c_char, c_int, c_void},
     ptr::{self, NonNull},
     sync::atomic::{AtomicPtr, Ordering},
 };
@@ -147,13 +147,12 @@ impl API {
 
     pub(crate) fn plugin_by_namespace<'core>(
         &self,
-        namespace: &str,
+        namespace: *const c_char,
         core: &CoreRef<'core>,
     ) -> Option<Plugin<'core>> {
         unsafe {
-            let ns = CString::new(namespace).unwrap();
             let handle =
-                self.handle.as_ref().getPluginByNamespace.unwrap()(ns.as_ptr(), core.as_ptr());
+                self.handle.as_ref().getPluginByNamespace.unwrap()(namespace, core.as_ptr());
             if handle.is_null() {
                 None
             } else {
@@ -164,12 +163,11 @@ impl API {
 
     pub(crate) fn plugin_by_id<'core>(
         &self,
-        id: &str,
+        id: *const c_char,
         core: &'core CoreRef<'core>,
     ) -> Option<Plugin<'core>> {
         unsafe {
-            let id = CString::new(id).unwrap();
-            let handle = self.handle.as_ref().getPluginByID.unwrap()(id.as_ptr(), core.as_ptr());
+            let handle = self.handle.as_ref().getPluginByID.unwrap()(id, core.as_ptr());
             if handle.is_null() {
                 None
             } else {
@@ -940,7 +938,7 @@ impl API {
     pub(crate) fn get_plugin_function_return_type(
         &self,
         function: *mut ffi::VSPluginFunction,
-    ) -> *const i8 {
+    ) -> *const c_char {
         unsafe { self.handle.as_ref().getPluginFunctionReturnType.unwrap()(function) }
     }
 

rustsynth/src/api.rs

@@ -14,7 +14,6 @@ use rustsynth_sys as ffi;
 use std::{
     ffi::{CStr, CString},
     marker::PhantomData,
-    mem,
     ptr::NonNull,
 };
 
@@ -36,7 +35,7 @@ bitflags! {
 }
 
 /// A reference to a VapourSynth core.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CoreRef<'core> {
     handle: NonNull<ffi::VSCore>,
     _owner: PhantomData<&'core ()>,
@@ -48,11 +47,6 @@ unsafe impl<'core> Sync for CoreRef<'core> {}
 impl<'core> CoreRef<'core> {
     /// Creates and returns a new core.
     ///
-    /// Note that there's currently no safe way of freeing the returned core, and the lifetime is
-    /// unbounded, because it can live for an arbitrary long time. You may use the (unsafe)
-    /// `rustsynth_sys::VSAPI::freeCore()` after ensuring that all frame requests have completed
-    /// and all objects belonging to the core have been released.
-    ///
     /// # Example
     ///
     /// ```
@@ -111,14 +105,34 @@ impl<'core> CoreRef<'core> {
     ///
     /// [None] if no plugin is found
     pub fn plugin_by_namespace(&self, namespace: &str) -> Option<Plugin<'core>> {
-        unsafe { API::get_cached() }.plugin_by_namespace(namespace, self)
+        let namespace = CString::new(namespace).unwrap();
+        unsafe { API::get_cached() }.plugin_by_namespace(namespace.as_ptr(), self)
     }
 
     /// Returns an instance of [Some]<[Plugin]> if there exists a plugin loaded associated with the id
     ///
     /// [None] if no plugin is found
     pub fn plugin_by_id(&self, id: &str) -> Option<Plugin<'_>> {
-        unsafe { API::get_cached() }.plugin_by_id(id, self)
+        let id = CString::new(id).unwrap();
+        unsafe { API::get_cached() }.plugin_by_id(id.as_ptr(), self)
+    }
+
+    pub fn std(&self) -> Option<Plugin<'_>> {
+        unsafe {
+            API::get_cached().plugin_by_id(ffi::VSH_STD_PLUGIN_ID.as_ptr() as *const i8, self)
+        }
+    }
+
+    pub fn resize(&self) -> Option<Plugin<'_>> {
+        unsafe {
+            API::get_cached().plugin_by_id(ffi::VSH_RESIZE_PLUGIN_ID.as_ptr() as *const i8, self)
+        }
+    }
+
+    pub fn text(&self) -> Option<Plugin<'_>> {
+        unsafe {
+            API::get_cached().plugin_by_id(ffi::VSH_TEXT_PLUGIN_ID.as_ptr() as *const i8, self)
+        }
     }
 
     /// Returns a iterator over the loaded plugins
@@ -194,9 +208,9 @@ impl<'core> CoreRef<'core> {
     }
 
     /// Create a video filter using the Filter trait
-    pub fn create_video_filter<F>(&self, filter: F) -> Result<OwnedMap<'_>, String>
+    pub fn create_video_filter<F>(&self, filter: &F) -> Result<OwnedMap<'_>, String>
     where
-        F: Filter + Send + Sync + 'static,
+        F: Filter<'core>,
     {
         let out = OwnedMap::new();
         // Get video info from the filter
@@ -233,9 +247,9 @@ impl<'core> CoreRef<'core> {
     }
 
     /// Create a video filter using the Filter trait (returns node directly)
-    pub fn create_video_filter2<F>(&self, filter: F) -> Result<crate::node::Node, String>
+    pub fn create_video_filter2<F>(&self, filter: &F) -> Result<crate::node::Node<'core>, String>
     where
-        F: Filter + Send + Sync + 'static,
+        F: Filter<'core>,
     {
         // Get video info from the filter
         let video_info = filter.get_video_info()?;
@@ -274,9 +288,9 @@ impl<'core> CoreRef<'core> {
     }
 
     /// Create a audio filter using the Filter trait
-    pub fn create_audio_filter<F>(&self, filter: F) -> Result<OwnedMap<'_>, String>
+    pub fn create_audio_filter<F>(&self, filter: &F) -> Result<OwnedMap<'_>, String>
     where
-        F: Filter + Send + Sync + 'static,
+        F: Filter<'core>,
     {
         let out = OwnedMap::new();
         // Get audio info from the filter
@@ -313,9 +327,9 @@ impl<'core> CoreRef<'core> {
     }
 
     /// Create an audio filter using the Filter trait (returns node directly)
-    pub fn create_audio_filter2<F>(&self, filter: F) -> Result<crate::node::Node, String>
+    pub fn create_audio_filter2<F>(&self, filter: &F) -> Result<crate::node::Node<'core>, String>
     where
-        F: Filter + Send + Sync + 'static,
+        F: Filter<'core>,
     {
         // Get audio info from the filter
         let audio_info = filter.get_audio_info()?;
@@ -355,7 +369,7 @@ impl<'core> CoreRef<'core> {
 }
 
 // Callback functions for Filter trait integration
-unsafe extern "C" fn filter_get_frame<F>(
+unsafe extern "C" fn filter_get_frame<'core, F>(
     n: i32,
     activation_reason: i32,
     instance_data: *mut std::ffi::c_void,
@@ -365,7 +379,7 @@ unsafe extern "C" fn filter_get_frame<F>(
     _vs_api: *const ffi::VSAPI,
 ) -> *const ffi::VSFrame
 where
-    F: Filter + Send + Sync + 'static,
+    F: Filter<'core>,
 {
     if instance_data.is_null() || frame_ctx.is_null() || core.is_null() {
         return std::ptr::null();
@@ -398,10 +412,7 @@ where
             };
 
             match filter.process_frame(n, &frame_data_array, &frame_context, core_ref) {
-                Ok(frame) => {
-                    let frame = mem::ManuallyDrop::new(frame);
-                    frame.as_ptr()
-                }
+                Ok(frame) => frame.as_ptr(),
                 Err(error) => {
                     frame_context.set_filter_error(&error);
                     std::ptr::null()
@@ -428,12 +439,12 @@ where
     }
 }
 
-unsafe extern "C" fn filter_free<F>(
+unsafe extern "C" fn filter_free<'core, F>(
     instance_data: *mut std::ffi::c_void,
     _core: *mut ffi::VSCore,
     _vs_api: *const ffi::VSAPI,
 ) where
-    F: Filter + Send + Sync + 'static,
+    F: Filter<'core>,
 {
     if !instance_data.is_null() {
         let filter = Box::from_raw(instance_data as *mut F);

rustsynth/src/core.rs

@@ -5,12 +5,12 @@ use crate::ffi;
 use crate::ffi::VSRequestPattern;
 use crate::node::Node;
 
-pub struct FilterDependency {
-    pub source: Node,
+pub struct FilterDependency<'core> {
+    pub source: Node<'core>,
     pub request_pattern: RequestPattern,
 }
 
-impl FilterDependency {
+impl FilterDependency<'_> {
     pub const fn as_ffi(&self) -> ffi::VSFilterDependency {
         ffi::VSFilterDependency {
             source: self.source.as_ptr(),

rustsynth/src/filter/mod.rs

@@ -7,19 +7,19 @@ use crate::{
 };
 
 /// Trait that filter structs must implement
-pub trait Filter {
+pub trait Filter<'core>: Send + Sync + Clone + 'core {
     const NAME: &'static str;
     const ARGS: &'static str;
     const RETURNTYPE: &'static str;
     const MODE: FilterMode;
 
     /// Create filter instance from input arguments and core
-    fn from_args(args: &Map, core: &CoreRef) -> Result<Self, String>
+    fn from_args(args: &Map<'core>, core: &CoreRef<'core>) -> Result<Self, String>
     where
         Self: Sized;
 
     /// Get filter dependencies
-    fn get_dependencies(&self) -> Vec<FilterDependency>;
+    fn get_dependencies(&self) -> Vec<FilterDependency<'core>>;
 
     /// Get video info for video filters - override for source filters
     fn get_video_info(&self) -> Result<VideoInfo, String> {
@@ -53,7 +53,7 @@ pub trait Filter {
     fn request_input_frames(&self, n: i32, frame_ctx: &FrameContext);
 
     /// Process frame n and return output frame
-    fn process_frame<'core>(
+    fn process_frame(
         &mut self,
         n: i32,
         _frame_data: &[u8; 4],

rustsynth/src/filter/traits.rs

@@ -24,12 +24,6 @@ pub struct Frame<'core> {
 unsafe impl<'core> Send for Frame<'core> {}
 unsafe impl<'core> Sync for Frame<'core> {}
 
-impl<'core> Drop for Frame<'core> {
-    fn drop(&mut self) {
-        unsafe { API::get_cached().free_frame(self.handle.as_ptr()) }
-    }
-}
-
 /// Represents a reference to the obscure object
 #[derive(Debug)]
 pub struct FrameContext {
@@ -75,6 +69,12 @@ impl<'core> Frame<'core> {
         }
     }
 
+    /// # Safety
+    /// The frame must be owned (not borrowed) and not passed to vapoursynth core.
+    pub unsafe fn free(self) {
+        API::get_cached().free_frame(self.handle.as_ptr());
+    }
+
     #[inline]
     pub const fn as_ptr(&self) -> *const ffi::VSFrame {
         self.handle.as_ptr()

rustsynth/src/frame/mod.rs

@@ -63,7 +63,6 @@ impl<'core> Function<'core> {
     /// Creates a new function.
     ///
     /// To indicate an error from the callback, set an error on the output map.
-    #[inline]
     pub fn new<F>(core: CoreRef<'core>, callback: F) -> Self
     where
         F: Fn(CoreRef<'core>, &Map<'core>, &mut Map<'core>) + Send + Sync + 'core,

rustsynth/src/function.rs

@@ -116,7 +116,12 @@ impl_value_iter!(
     get_data_raw_unchecked,
     new_data
 );
-impl_value_iter!(ValueType::Node, Node, get_node_raw_unchecked, new_node);
+impl_value_iter!(
+    ValueType::Node,
+    Node<'elem>,
+    get_node_raw_unchecked,
+    new_node
+);
 impl_value_iter!(
     ValueType::Frame,
     Frame<'elem>,

rustsynth/src/map/iterators.rs

@@ -548,14 +548,17 @@ impl<'elem> Map<'elem> {
     ///
     /// This function retrieves the first value associated with the key.
     #[inline]
-    pub fn get_node(&self, key: &str) -> MapResult<Node> {
+    pub fn get_node(&self, key: &str) -> MapResult<Node<'elem>> {
         let key = Map::make_raw_key(key)?;
         unsafe { self.get_node_raw_unchecked(&key, 0) }
     }
 
     /// Retrieves nodes from a map.
     #[inline]
-    pub fn get_node_iter<'map>(&'map self, key: &str) -> MapResult<ValueIter<'map, 'elem, Node>> {
+    pub fn get_node_iter<'map>(
+        &'map self,
+        key: &str,
+    ) -> MapResult<ValueIter<'map, 'elem, Node<'elem>>> {
         let key = Map::make_raw_key(key)?;
         unsafe { ValueIter::new_node(self, key) }
     }
@@ -674,7 +677,11 @@ impl<'elem> Map<'elem> {
     /// # Safety
     /// The caller must ensure `key` is valid.
     #[inline]
-    pub(crate) unsafe fn get_node_raw_unchecked(&self, key: &CStr, index: i32) -> MapResult<Node> {
+    pub(crate) unsafe fn get_node_raw_unchecked(
+        &self,
+        key: &CStr,
+        index: i32,
+    ) -> MapResult<Node<'elem>> {
         let mut error = 0;
         let value = API::get_cached().map_get_node(self, key.as_ptr(), index, &mut error);
         handle_get_prop_error(error)?;