Remove Sync requirement from ProcessHandler. (#121) (#127)

RustAudio · Sep 5, 2020 · 0b60934 · 0b60934
1 parent 41fab12
commit 0b60934
Show file tree

Hide file tree

Showing 5 changed files with 53 additions and 17 deletions.
diff --git a/src/client/async_client.rs b/src/client/async_client.rs
@@ -33,7 +33,7 @@ pub struct AsyncClient<N, P> {
 impl<N, P> AsyncClient<N, P>
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     /// Tell the JACK server that the program is ready to start processing audio. JACK will call the
     /// methods specified by the `NotificationHandler` and `ProcessHandler` objects.

diff --git a/src/client/callbacks.rs b/src/client/callbacks.rs
@@ -155,7 +155,7 @@ pub trait ProcessHandler: Send {
 unsafe extern "C" fn thread_init_callback<N, P>(data: *mut libc::c_void)
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     ctx.notification.thread_init(&ctx.client)
@@ -167,7 +167,7 @@ unsafe extern "C" fn shutdown<N, P>(
     data: *mut libc::c_void,
 ) where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let cstr = ffi::CStr::from_ptr(reason);
@@ -184,7 +184,7 @@ unsafe extern "C" fn shutdown<N, P>(
 unsafe extern "C" fn process<N, P>(n_frames: Frames, data: *mut libc::c_void) -> libc::c_int
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let scope = ProcessScope::from_raw(n_frames, ctx.client.raw());
@@ -194,7 +194,7 @@ where
 unsafe extern "C" fn freewheel<N, P>(starting: libc::c_int, data: *mut libc::c_void)
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let is_starting = match starting {
@@ -207,7 +207,7 @@ where
 unsafe extern "C" fn buffer_size<N, P>(n_frames: Frames, data: *mut libc::c_void) -> libc::c_int
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     ctx.notification.buffer_size(&ctx.client, n_frames).to_ffi()
@@ -216,7 +216,7 @@ where
 unsafe extern "C" fn sample_rate<N, P>(n_frames: Frames, data: *mut libc::c_void) -> libc::c_int
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     ctx.notification.sample_rate(&ctx.client, n_frames).to_ffi()
@@ -228,7 +228,7 @@ unsafe extern "C" fn client_registration<N, P>(
     data: *mut libc::c_void,
 ) where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let name = ffi::CStr::from_ptr(name).to_str().unwrap();
@@ -246,7 +246,7 @@ unsafe extern "C" fn port_registration<N, P>(
     data: *mut libc::c_void,
 ) where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let register = match register {
@@ -266,7 +266,7 @@ unsafe extern "C" fn port_rename<N, P>(
 ) -> libc::c_int
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let old_name = ffi::CStr::from_ptr(old_name).to_str().unwrap();
@@ -283,7 +283,7 @@ unsafe extern "C" fn port_connect<N, P>(
     data: *mut libc::c_void,
 ) where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let are_connected = match connect {
@@ -297,7 +297,7 @@ unsafe extern "C" fn port_connect<N, P>(
 unsafe extern "C" fn graph_order<N, P>(data: *mut libc::c_void) -> libc::c_int
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     ctx.notification.graph_reorder(&ctx.client).to_ffi()
@@ -306,7 +306,7 @@ where
 unsafe extern "C" fn xrun<N, P>(data: *mut libc::c_void) -> libc::c_int
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     ctx.notification.xrun(&ctx.client).to_ffi()
@@ -315,7 +315,7 @@ where
 unsafe extern "C" fn latency<N, P>(mode: j::jack_latency_callback_mode_t, data: *mut libc::c_void)
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     let ctx = CallbackContext::<N, P>::from_raw(data);
     let mode = match mode {
@@ -354,7 +354,7 @@ pub struct CallbackContext<N, P> {
 impl<N, P> CallbackContext<N, P>
 where
     N: 'static + Send + Sync + NotificationHandler,
-    P: 'static + Send + Sync + ProcessHandler,
+    P: 'static + Send + ProcessHandler,
 {
     pub unsafe fn from_raw<'a>(ptr: *mut libc::c_void) -> &'a mut CallbackContext<N, P> {
         debug_assert!(!ptr.is_null());

diff --git a/src/client/client.rs b/src/client/client.rs
@@ -61,7 +61,7 @@ impl Client {
     ) -> Result<AsyncClient<N, P>, Error>
     where
         N: 'static + Send + Sync + NotificationHandler,
-        P: 'static + Send + Sync + ProcessHandler,
+        P: 'static + Send + ProcessHandler,
     {
         AsyncClient::new(self, notification_handler, process_handler)
     }

diff --git a/src/jack_enums.rs b/src/jack_enums.rs
@@ -40,6 +40,15 @@ pub enum LatencyType {
     Playback,
 }
 
+impl LatencyType {
+    pub fn to_ffi(self) -> libc::c_uint {
+        match self {
+            LatencyType::Playback => jack_sys::JackPlaybackLatency,
+            LatencyType::Capture => jack_sys::JackCaptureLatency,
+        }
+    }
+}
+
 /// Specify an option, either to continue processing, or to stop.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Control {

diff --git a/src/port/port.rs b/src/port/port.rs
@@ -6,7 +6,7 @@ use std::marker::Sized;
 use std::sync::Weak;
 use std::{ffi, fmt, iter};
 
-use crate::{Error, Frames, PortFlags};
+use crate::{Error, Frames, LatencyType, PortFlags};
 
 lazy_static! {
     /// The maximum string length for port names.
@@ -273,6 +273,33 @@ impl<PS> Port<PS> {
         j::jack_port_get_buffer(self.port_ptr, n_frames)
     }
 
+    /// Set the minimum and maximum latencies defined by mode for port, in frames.
+    /// The `range` argument is a tuple of `(min, max)`.
+    ///
+    /// See [Managing and determining latency](https://jackaudio.org/api/group__LatencyFunctions.html)
+    /// for a description of what the latency values mean and some best practices. This function should
+    /// **only** be used inside a latency callback.
+    #[inline(always)]
+    pub fn set_latency_range(&self, mode: LatencyType, range: (Frames, Frames)) {
+        let mut ffi_range = j::Struct__jack_latency_range {
+            min: range.0,
+            max: range.1,
+        };
+        unsafe { j::jack_port_set_latency_range(self.port_ptr, mode.to_ffi(), &mut ffi_range) };
+    }
+
+    /// Returns a tuple of the minimum and maximum latencies defined by mode for port, in frames.
+    ///
+    /// See [Managing and determining latency](https://jackaudio.org/api/group__LatencyFunctions.html)
+    /// for a description of what the latency values mean and some best practices. This is normally
+    /// used in the LatencyCallback. and therefore safe to execute from callbacks.
+    #[inline(always)]
+    pub fn get_latency_range(&self, mode: LatencyType) -> (Frames, Frames) {
+        let mut ffi_range = j::Struct__jack_latency_range { min: 0, max: 0 };
+        unsafe { j::jack_port_get_latency_range(self.port_ptr, mode.to_ffi(), &mut ffi_range) };
+        return (ffi_range.min, ffi_range.max);
+    }
+
     fn check_client_life(&self) -> Result<(), Error> {
         self.client_life
             .upgrade()