Interface ProcessHandler

src/client/callbacks.rs:79–123

Specifies real-time processing.

/// Specifies real-time processing.
pub trait ProcessHandler: Send {
    /// Indicates whether or not this process handler represents a
    /// slow-sync client
    const SLOW_SYNC: bool = false;

    /// Called whenever there is work to be done.
    ///
    /// It needs to be suitable for real-time execution. That means that it
    /// cannot call functions
    /// that might block for a long time. This includes all I/O functions
    /// (disk, TTY, network),
    /// malloc, free, printf, pthread_mutex_lock, sleep, wait, poll, select,
    /// pthread_join,
    /// pthread_cond_wait, etc, etc.
    ///
    /// Should return `Control::Continue` on success, and
    /// `Control::Quit` on error.
    fn process(&mut self, _: &Client, _process_scope: &ProcessScope) -> Control;

    /// Called whenever the size of the buffer that will be passed to `process`
    /// is about to change, and once before the first call to `process`.
    ///
    /// It is called on the same thread as `process`, but as an exception, does
    /// not need to be suitable for real-time execution, so it is allowed to
    /// allocate new buffers to accomodate the buffer size for example.
    fn buffer_size(&mut self, _: &Client, _size: Frames) -> Control {
        Control::Continue
    }

    /// For slow-sync clients, called periodically when the transport position
    /// is changed.  The transport will not start rolling until all clients
    /// indicate they are ready, or a timeout occurs.
    ///
    /// It should return `false` until the handler is ready process audio.
    ///
    /// Ignored unless Self::SLOW_SYNC == true.
    fn sync(
        &mut self,
        _: &Client,
        _state: crate::TransportState,
        _pos: &crate::TransportPosition,
    ) -> bool {
        true
    }
}

unsafe extern "C" fn thread_init_callback<N, P>(data: *mut libc::c_void)
where