Merge pull request #31 from Boscop/master

Use types from std::os::raw instead of libc where possible

Author: overdrivenpotato

examples/sine_synth/Cargo.toml

@@ -8,4 +8,4 @@ vst2 = { git = "https://github.com/overdrivenpotato/rust-vst2" }
 
 [lib]
 name = "sine_synth"
-crate-type = ["dylib"]
+crate-type = ["cdylib"]

examples/sine_synth/src/lib.rs

@@ -1,8 +1,9 @@
 #[macro_use] extern crate vst2;
 
 use vst2::buffer::AudioBuffer;
-use vst2::plugin::{Category, Plugin, Info};
-use vst2::event::{Event};
+use vst2::plugin::{Category, Plugin, Info, CanDo};
+use vst2::event::Event;
+use vst2::api::Supported;
 
 use std::f64::consts::PI;
 
@@ -137,6 +138,13 @@ impl Plugin for SineSynth {
         self.time += samples as f64 * per_sample;
         self.note_duration += samples as f64 * per_sample;
     }
+
+    fn can_do(&self, can_do: CanDo) -> Supported {
+        match can_do {
+            CanDo::ReceiveMidiEvent => Supported::Yes,
+            _ => Supported::Maybe
+        }
+    }
 }
 
 plugin_main!(SineSynth);

src/api.rs

@@ -1,22 +1,21 @@
 //! Structures and types for interfacing with the VST 2.4 API.
 use std::mem;
 
-use libc::c_void;
+use std::os::raw::c_void;
 
 use plugin::Plugin;
 use self::consts::*;
 
 /// Constant values
 #[allow(missing_docs)] // For obvious constants
 pub mod consts {
-    use libc::size_t;
 
-    pub const MAX_PRESET_NAME_LEN: size_t = 24;
-    pub const MAX_PARAM_STR_LEN: size_t = 32;
+    pub const MAX_PRESET_NAME_LEN: usize = 24;
+    pub const MAX_PARAM_STR_LEN: usize = 32;
     pub const MAX_LABEL: usize = 64;
     pub const MAX_SHORT_LABEL: usize = 8;
-    pub const MAX_PRODUCT_STR_LEN: size_t = 64;
-    pub const MAX_VENDOR_STR_LEN: size_t = 64;
+    pub const MAX_PRODUCT_STR_LEN: usize = 64;
+    pub const MAX_VENDOR_STR_LEN: usize = 64;
 
     /// VST plugins are identified by a magic number. This corresponds to 0x56737450.
     pub const VST_MAGIC: i32 = ('V' as i32) << 24 |

src/editor.rs

@@ -1,6 +1,6 @@
 //! All VST plugin editor related functionality.
 
-use libc::c_void;
+use std::os::raw::c_void;
 
 /// Implemented by plugin editors.
 #[allow(unused_variables)]

src/host.rs

@@ -7,7 +7,7 @@ use std::{fmt, mem, ptr, slice};
 use std::ffi::CString;
 
 use libloading::Library;
-use libc::c_void;
+use std::os::raw::c_void;
 
 use interfaces;
 use plugin::{self, Plugin, Info, Category};
@@ -339,7 +339,7 @@ impl<T: Host> PluginLoader<T> {
 
     /// Call the VST entry point and retrieve a (possibly null) pointer.
     unsafe fn call_main(&mut self) -> *mut AEffect {
-        load_pointer = Box::into_raw(Box::new(self.host.clone())) as *mut c_void;
+        LOAD_POINTER = Box::into_raw(Box::new(self.host.clone())) as *mut c_void;
         (self.main)(callback_wrapper::<T>)
     }
 
@@ -666,7 +666,7 @@ impl Plugin for PluginInstance {
 /// this is a rare situation as you normally won't have 2 seperate host instances loading at once.
 ///
 /// [reserved field]: ../api/struct.AEffect.html#structfield.reserved1
-static mut load_pointer: *mut c_void = 0 as *mut c_void;
+static mut LOAD_POINTER: *mut c_void = 0 as *mut c_void;
 
 /// Function passed to plugin to handle dispatching host opcodes.
 fn callback_wrapper<T: Host>(effect: *mut AEffect, opcode: i32, index: i32,
@@ -681,11 +681,11 @@ fn callback_wrapper<T: Host>(effect: *mut AEffect, opcode: i32, index: i32,
             let host = &mut *host.lock().unwrap();
 
             interfaces::host_dispatch(host, effect, opcode, index, value, ptr, opt)
-        // In this case, the plugin is still undergoing initialization and so `load_pointer` is
+        // In this case, the plugin is still undergoing initialization and so `LOAD_POINTER` is
         // dereferenced
         } else {
             // Used only during the plugin initialization
-            let host = load_pointer as *const Arc<Mutex<T>>;
+            let host = LOAD_POINTER as *const Arc<Mutex<T>>;
             let host = &*host;
             let host = &mut *host.lock().unwrap();
 

src/interfaces.rs

@@ -2,10 +2,9 @@
 
 #![doc(hidden)]
 
-use std::ffi::{CStr, CString};
 use std::{mem, slice};
 
-use libc::{self, size_t, c_char, c_void};
+use std::os::raw::{c_char, c_void};
 
 use buffer::AudioBuffer;
 use api::consts::*;
@@ -60,6 +59,20 @@ pub fn get_parameter(effect: *mut AEffect, index: i32) -> f32 {
     unsafe { (*effect).get_plugin() }.get_parameter(index)
 }
 
+/// Copy a string into a destination buffer.
+///
+/// String will be cut at `max` characters.
+fn copy_string(dst: *mut c_void, src: &str, max: usize) {
+    unsafe {
+        use std::cmp::min;
+        use libc::{c_void, memset, memcpy};
+
+        let dst = dst as *mut c_void;
+        memset(dst, 0, max);
+        memcpy(dst, src.as_ptr() as *const c_void, min(max, src.len()));
+    }
+}
+
 /// VST2.4 dispatch function. This function handles dispatching all opcodes to the vst plugin.
 pub fn dispatch(effect: *mut AEffect, opcode: i32, index: i32, value: isize, ptr: *mut c_void, opt: f32) -> isize {
     use plugin::{CanDo, OpCode};
@@ -69,15 +82,6 @@ pub fn dispatch(effect: *mut AEffect, opcode: i32, index: i32, value: isize, ptr
     // Plugin handle
     let mut plugin = unsafe { (*effect).get_plugin() };
 
-    // Copy a string into the `ptr` buffer
-    let copy_string = |string: &String, max: size_t| {
-        unsafe {
-            libc::strncpy(ptr as *mut c_char,
-                          CString::new(string.clone()).unwrap().as_ptr(),
-                          max);
-        }
-    };
-
     match opcode {
         OpCode::Initialize => plugin.init(),
         OpCode::Shutdown => unsafe {
@@ -90,12 +94,12 @@ pub fn dispatch(effect: *mut AEffect, opcode: i32, index: i32, value: isize, ptr
         OpCode::SetCurrentPresetName => plugin.set_preset_name(read_string(ptr)),
         OpCode::GetCurrentPresetName => {
             let num = plugin.get_preset_num();
-            copy_string(&plugin.get_preset_name(num), MAX_PRESET_NAME_LEN);
+            copy_string(ptr, &plugin.get_preset_name(num), MAX_PRESET_NAME_LEN);
         }
 
-        OpCode::GetParameterLabel => copy_string(&plugin.get_parameter_label(index), MAX_PARAM_STR_LEN),
-        OpCode::GetParameterDisplay => copy_string(&plugin.get_parameter_text(index), MAX_PARAM_STR_LEN),
-        OpCode::GetParameterName => copy_string(&plugin.get_parameter_name(index), MAX_PARAM_STR_LEN),
+        OpCode::GetParameterLabel => copy_string(ptr, &plugin.get_parameter_label(index), MAX_PARAM_STR_LEN),
+        OpCode::GetParameterDisplay => copy_string(ptr, &plugin.get_parameter_text(index), MAX_PARAM_STR_LEN),
+        OpCode::GetParameterName => copy_string(ptr, &plugin.get_parameter_name(index), MAX_PARAM_STR_LEN),
 
         OpCode::SetSampleRate => plugin.set_sample_rate(opt),
         OpCode::SetBlockSize => plugin.set_block_size(value as i64),
@@ -184,7 +188,7 @@ pub fn dispatch(effect: *mut AEffect, opcode: i32, index: i32, value: isize, ptr
         OpCode::CanBeAutomated => return plugin.can_be_automated(index) as isize,
         OpCode::StringToParameter => return plugin.string_to_parameter(index, read_string(ptr)) as isize,
 
-        OpCode::GetPresetName => copy_string(&plugin.get_preset_name(index), MAX_PRESET_NAME_LEN),
+        OpCode::GetPresetName => copy_string(ptr, &plugin.get_preset_name(index), MAX_PRESET_NAME_LEN),
 
         OpCode::GetInputInfo => {
             if index >= 0 && index < plugin.get_info().inputs {
@@ -206,8 +210,8 @@ pub fn dispatch(effect: *mut AEffect, opcode: i32, index: i32, value: isize, ptr
             return plugin.get_info().category.into();
         }
 
-        OpCode::GetVendorName => copy_string(&plugin.get_info().vendor, MAX_VENDOR_STR_LEN),
-        OpCode::GetProductName => copy_string(&plugin.get_info().name, MAX_PRODUCT_STR_LEN),
+        OpCode::GetVendorName => copy_string(ptr, &plugin.get_info().vendor, MAX_VENDOR_STR_LEN),
+        OpCode::GetProductName => copy_string(ptr, &plugin.get_info().name, MAX_PRODUCT_STR_LEN),
         OpCode::GetVendorVersion => return plugin.get_info().version as isize,
         OpCode::VendorSpecific => return plugin.vendor_specific(index, value, ptr, opt),
         OpCode::CanDo => {
@@ -265,15 +269,6 @@ pub fn host_dispatch(host: &mut Host,
                      opt: f32) -> isize {
     use host::OpCode;
 
-    // Copy a string into the `ptr` buffer
-    let copy_string = |string: &String, max: size_t| {
-        unsafe {
-            libc::strncpy(ptr as *mut c_char,
-                          CString::new(string.clone()).unwrap().as_ptr(),
-                          max);
-        }
-    };
-
     match OpCode::from(opcode) {
         OpCode::Version => return 2400,
         OpCode::Automate => host.automate(index, opt),
@@ -287,8 +282,8 @@ pub fn host_dispatch(host: &mut Host,
         }
 
         OpCode::GetVendorVersion => return host.get_info().0,
-        OpCode::GetVendorString => copy_string(&host.get_info().1, MAX_VENDOR_STR_LEN),
-        OpCode::GetProductString => copy_string(&host.get_info().2, MAX_PRODUCT_STR_LEN),
+        OpCode::GetVendorString => copy_string(ptr, &host.get_info().1, MAX_VENDOR_STR_LEN),
+        OpCode::GetProductString => copy_string(ptr, &host.get_info().2, MAX_PRODUCT_STR_LEN),
         OpCode::ProcessEvents => {
             let events: *const api::Events = ptr as *const api::Events;
 
@@ -313,6 +308,8 @@ pub fn host_dispatch(host: &mut Host,
 
 // Read a string from the `ptr` buffer
 fn read_string(ptr: *mut c_void) -> String {
+    use std::ffi::CStr;
+
     String::from_utf8_lossy(
         unsafe { CStr::from_ptr(ptr as *mut c_char).to_bytes() }
     ).into_owned()

src/lib.rs

@@ -252,7 +252,7 @@ pub fn main<T: Plugin + Default>(callback: HostCallbackProc) -> *mut AEffect {
 mod tests {
     use std::ptr;
 
-    use libc::c_void;
+    use std::os::raw::c_void;
 
     use interfaces;
     use api::AEffect;

src/plugin.rs

@@ -2,7 +2,7 @@
 
 use std::{mem, ptr};
 
-use libc::c_void;
+use std::os::raw::c_void;
 
 use channels::ChannelInfo;
 use host::{self, Host};
@@ -850,7 +850,7 @@ mod tests {
     /// This is a macro to allow you to specify attributes on the created struct.
     macro_rules! make_plugin {
         ($($attr:meta) *) => {
-            use libc::c_void;
+            use std::os::raw::c_void;
 
             use main;
             use api::AEffect;