Struct jack::Client

pub struct Client(_, _);

A client to interact with a JACK server.

Example

let c_res = jack::Client::new("rusty_client", jack::ClientOptions::NO_START_SERVER);
match c_res {
    Ok((client, status)) => println!(
        "Managed to open client {}, with
status {:?}!",
        client.name(),
        status
    ),
    Err(e) => println!("Failed to open client because of error: {:?}", e),
};

Implementations

impl Client

pub fn new(
    client_name: &str,
    options: ClientOptions
) -> Result<(Self, ClientStatus), Error>

Opens a JACK client with the given name and options. If the client is successfully opened, then Ok(client) is returned. If there is a failure, then Err(Error::ClientError(status)) will be returned.

Although the client may be successful in opening, there still may be some errors minor errors when attempting to opening. To access these, check the returned ClientStatus.

pub fn activate_async<N, P>(
    self,
    notification_handler: N,
    process_handler: P
) -> Result<AsyncClient<N, P>, Error> where
    N: 'static + Send + Sync + NotificationHandler,
    P: 'static + Send + ProcessHandler, 

Begin processing in real-time using the specified NotificationHandler and ProcessHandler.

pub fn sample_rate(&self) -> usize

The sample rate of the JACK system, as set by the user when jackd was started.

pub fn cpu_load(&self) -> f32

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.

pub fn name(&self) -> &str

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.

pub fn buffer_size(&self) -> Frames

The current maximum size that will every be passed to the process callback.

pub fn set_buffer_size(&self, n_frames: Frames) -> Result<(), Error>

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.

pub fn ports(
    &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, AudioIn and AudioOut 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.

pub fn register_port<PS: PortSpec>(
    &self,
    port_name: &str,
    port_spec: PS
) -> Result<Port<PS>, Error>

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 (AudioIn, AudioOut, MidiIn, MidiOut) 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.

pub fn port_by_id(&self, port_id: PortId) -> Option<Port<Unowned>>

Get a Port by its port id.

pub fn port_by_name(&self, port_name: &str) -> Option<Port<Unowned>>

Get a Port by its port name.

pub fn frames_since_cycle_start(&self) -> Frames

The estimated time in frames that has passed since the JACK server began the current process cycle.

pub fn frame_time(&self) -> Frames

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

pub fn frames_to_time(&self, n_frames: Frames) -> Time

The estimated time in microseconds of the specified frame time

TODO

• Improve test

pub fn time_to_frames(&self, t: Time) -> Frames

The estimated time in frames for the specified system time.

TODO

• Improve test

pub fn is_mine<PS: PortSpec>(&self, port: &Port<PS>) -> bool

Returns true if the port port belongs to this client.

pub fn request_monitor_by_name(
    &self,
    port_name: &str,
    enable_monitor: bool
) -> Result<(), Error>

Toggle input monitoring for the port with name port_name.

Err(Error::PortMonitorError) is returned on failure.

Only works if the port has the CAN_MONITOR flag, or else nothing happens.

pub fn connect_ports_by_name(
    &self,
    source_port: &str,
    destination_port: &str
) -> Result<(), Error>

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

1. The port types must be identical
2. The port flags of the source_port must include IS_OUTPUT
3. The port flags of the destination_port must include IS_INPUT.
4. Both ports must be owned by active clients.

pub fn connect_ports<A: PortSpec, B: PortSpec>(
    &self,
    source_port: &Port<A>,
    destination_port: &Port<B>
) -> Result<(), Error>

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

1. The port types must be identical
2. The port flags of the source_port must include IS_OUTPUT
3. The port flags of the destination_port must include IS_INPUT.
4. Both ports must be owned by active clients.

pub fn disconnect<PS>(&self, port: &Port<PS>) -> Result<(), Error>

Remove all connections to/from the port.

pub fn unregister_port<PS>(&self, port: Port<PS>) -> Result<(), Error>

pub fn disconnect_ports<A: PortSpec, B: PortSpec>(
    &self,
    source: &Port<A>,
    destination: &Port<B>
) -> Result<(), Error>

Remove a connection between two ports.

pub fn disconnect_ports_by_name(
    &self,
    source_port: &str,
    destination_port: &str
) -> Result<(), Error>

Remove a connection between two ports.

pub unsafe fn type_buffer_size(&self, port_type: &str) -> usize

The buffer size of a port type

Unsafe

• This function may only be called in a buffer size callback.

pub fn raw(&self) -> *mut jack_client_t

Expose the underlying ffi pointer.

This is mostly for use within the jack crate itself.

pub unsafe fn from_raw(p: *mut jack_client_t) -> Self

Create a Client from an ffi pointer.

This is mostly for use within the jack crate itself.

Trait Implementations

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Drop for Client

Close the client.

fn drop(&mut self)

Executes the destructor for this type.

impl Send for Client