Struct jack::prelude::AsyncClient
[−]
[src]
pub struct AsyncClient<N: NotificationHandler, P: ProcessHandler> { /* fields omitted */ }
A JACK client that is processing data asynchronously, in real-time.
To create input or output (either sound or midi), a Port
can be used within the process
callback. See Client::register_port
on creating ports. Also, see Port
for documentation on
the API for port.
Example
use jack::prelude as j; // Create a client and a handler let (client, _status) = j::Client::new("my_client", j::client_options::NO_START_SERVER) .unwrap(); let process_handler = j::ClosureProcessHandler::new( move |_: &j::Client, _: &j::ProcessScope| { j::JackControl::Continue } ); // An active async client is created, `client` is consumed. let active_client = j::AsyncClient::new(client, (), process_handler).unwrap();
Methods
impl<N, P> AsyncClient<N, P> where
N: NotificationHandler,
P: ProcessHandler,
[src]
N: NotificationHandler,
P: ProcessHandler,
fn new(
client: Client,
notification_handler: N,
process_handler: P
) -> Result<Self, JackErr>
[src]
client: Client,
notification_handler: N,
process_handler: P
) -> Result<Self, JackErr>
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.
On failure, either Err(JackErr::CallbackRegistrationError)
or
Err(JackErr::ClientActivationError)
is returned.
notification_handler
and process_handler
are consumed, but they are returned when
Client::deactivate
is called.
fn deactivate(self) -> Result<(Client, N, P), JackErr>
[src]
Tell the JACK server to remove this client from the process graph. Also, disconnect all ports belonging to it since inactive clients have no port connections.
The handler
that was used for Client::activate
is returned on success. Its state may
have changed due to JACK calling its methods.
In the case of error, the Client
is destroyed because its state is unknown, and it is
therefore unsafe to continue using.
Methods from Deref<Target = Client>
fn sample_rate(&self) -> usize
[src]
The sample rate of the JACK system, as set by the user when jackd was started.
fn cpu_load(&self) -> f32
[src]
The current CPU load estimated by JACK. It is on a scale of 0.0
to 100.0
.
This is a running average of the time it takes to execute a full process cycle for all clients as a percentage of the real time available per cycle determined by the buffer size and sample rate.
fn name<'a>(&'a self) -> &'a str
[src]
Get the name of the current client. This may differ from the name requested by
Client::new
as JACK will may rename a client if necessary (ie: name collision, name too
long). The name will only the be different than the one passed to Client::new
if the
ClientStatus
was NAME_NOT_UNIQUE
.
fn buffer_size(&self) -> JackFrames
[src]
The current maximum size that will every be passed to the process callback.
fn set_buffer_size(&self, n_frames: JackFrames) -> Result<(), JackErr>
[src]
Change the buffer size passed to the process callback.
This operation stops the JACK engine process cycle, then calls all registered buffer size callback functions before restarting the process cycle. This will cause a gap in the audio flow, so it should only be done at appropriate stopping points.
fn ports(
&self,
port_name_pattern: Option<&str>,
type_name_pattern: Option<&str>,
flags: PortFlags
) -> Vec<String>
[src]
&self,
port_name_pattern: Option<&str>,
type_name_pattern: Option<&str>,
flags: PortFlags
) -> Vec<String>
Returns a vector of port names that match the specified arguments
port_name_pattern
- A regular expression used to select ports by
name. If None
or zero lengthed, no selection based on name will be
carried out.
type_name_pattern
- A regular expression used to select ports by type. If None
or zero
lengthed, no selection based on type will be carried out. The port type is the same one
returned by PortSpec::jack_port_type()
. For example, AudioInSpec
and AudioOutSpec
are
both of type "32 bit float mono audio"
.
flags
- A value used to select ports by their flags. Use
PortFlags::empty()
for no flag selection.
fn register_port<PS: PortSpec>(
&self,
port_name: &str,
port_spec: PS
) -> Result<Port<PS>, JackErr>
[src]
&self,
port_name: &str,
port_spec: PS
) -> Result<Port<PS>, JackErr>
Create a new port for the client. This is an object used for moving data of any type in or out of the client. Ports may be connected in various ways.
The port_spec
specifies the IO direction and data type. Oftentimes, the built-in types
(AudioInSpec
, AudioOutSpec
, MidiInSpec
, MidiOutSpec
) can be used.
Each port has a short name. The port's full name contains the name of
the client concatenated with a colon (:) followed by its short
name. Port::name_size()
is the maximum length of the full
name. Exceeding that will cause the port registration to fail and return
Err(())
.
The port_name
must be unique among all ports owned by this client. If
the name is not unique, the registration will fail.
fn port_by_id(&self, port_id: JackPortId) -> Option<UnownedPort>
[src]
fn port_by_name(&self, port_name: &str) -> Option<UnownedPort>
[src]
Get a Port
by its port name.
fn frames_since_cycle_start(&self) -> JackFrames
[src]
The estimated time in frames that has passed since the JACK server began the current process cycle.
fn frame_time(&self) -> JackFrames
[src]
The estimated current time in frames. This function is intended for use in other threads
(not the process callback). The return value can be compared with the value of
last_frame_time
to relate time in other threads to JACK time. To obtain better time
information from within the process callback, see ProcessScope
.
TODO
- test
fn frames_to_time(&self, n_frames: JackFrames) -> JackTime
[src]
fn time_to_frames(&self, t: JackTime) -> JackFrames
[src]
fn is_mine<PS: PortSpec>(&self, port: &Port<PS>) -> bool
[src]
Returns true
if the port port
belongs to this client.
fn request_monitor_by_name(
&self,
port_name: &str,
enable_monitor: bool
) -> Result<(), JackErr>
[src]
&self,
port_name: &str,
enable_monitor: bool
) -> Result<(), JackErr>
Toggle input monitoring for the port with name port_name
.
Err(JackErr::PortMonitorError)
is returned on failure.
Only works if the port has the CAN_MONITOR
flag, or else nothing
happens.
fn connect_ports_by_name(
&self,
source_port: &str,
destination_port: &str
) -> Result<(), JackErr>
[src]
&self,
source_port: &str,
destination_port: &str
) -> Result<(), JackErr>
Establish a connection between two ports by their full name.
When a connection exists, data written to the source port will be available to be read at the destination port.
On failure, either a PortAlreadyConnected
or PortConnectionError
is returned.
Preconditions
- The port types must be identical
- The port flags of the
source_port
must includeIS_OUTPUT
- The port flags of the
destination_port
must includeIS_INPUT
. - Both ports must be owned by active clients.
fn connect_ports<A: PortSpec, B: PortSpec>(
&self,
source_port: &Port<A>,
destination_port: &Port<B>
) -> Result<(), JackErr>
[src]
&self,
source_port: &Port<A>,
destination_port: &Port<B>
) -> Result<(), JackErr>
Establish a connection between two ports.
When a connection exists, data written to the source port will be available to be read at the destination port.
On failure, either a PortAlreadyConnected
or PortConnectionError
is returned.
Preconditions
- The port types must be identical
- The port flags of the
source_port
must includeIS_OUTPUT
- The port flags of the
destination_port
must includeIS_INPUT
. - Both ports must be owned by active clients.
fn disconnect_ports<A: PortSpec, B: PortSpec>(
&self,
source: &Port<A>,
destination: &Port<B>
) -> Result<(), JackErr>
[src]
&self,
source: &Port<A>,
destination: &Port<B>
) -> Result<(), JackErr>
Remove a connection between two ports.
fn disconnect_ports_by_name(
&self,
source_port: &str,
destination_port: &str
) -> Result<(), JackErr>
[src]
&self,
source_port: &str,
destination_port: &str
) -> Result<(), JackErr>
Remove a connection between two ports.
unsafe fn type_buffer_size(&self, port_type: &str) -> usize
[src]
fn as_ptr(&self) -> *mut jack_client_t
[src]
Expose the underlying ffi pointer.
This is mostly for use within the jack crate itself.
Trait Implementations
impl<N: Debug + NotificationHandler, P: Debug + ProcessHandler> Debug for AsyncClient<N, P>
[src]
impl<N, P> Send for AsyncClient<N, P> where
N: NotificationHandler,
P: ProcessHandler,
[src]
N: NotificationHandler,
P: ProcessHandler,
impl<N, P> Deref for AsyncClient<N, P> where
N: NotificationHandler,
P: ProcessHandler,
[src]
N: NotificationHandler,
P: ProcessHandler,
type Target = Client
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
Dereferences the value.
impl<N, P> Drop for AsyncClient<N, P> where
N: NotificationHandler,
P: ProcessHandler,
[src]
N: NotificationHandler,
P: ProcessHandler,
Closes the client.