Struct Client

pub struct Client<'a> { /* private fields */ }

A jack client connected to a jack server

TODO example

Implementations

impl<'a> Client<'a>

pub fn open(name: &str, opts: Options) -> Result<(Self, String), Status>

Creates a new client and connects it to the default jack server. The client will use the name given. If the name is not unique, the behavior depends on the options provided via opts.

If the option to force a unique name is given (USE_EXACT_NAME) and the exact name can not be given, Err will be returned. Otherwise Returns the client and the name assigned to the client.

TODO client_name_size details in docs and in code

Examples found in repository

examples/simple_client.rs (line 113)

    fn new() -> Result<Self, jack::status::Status> {
        let client = jack::Client::open("simple", jack::options::NO_START_SERVER);
        let mut client = match client {
            Ok((client, _)) => client,
            Err(code)       => return Err(code),
        };

        // get some ports
        let right = client.register_output_audio_port("output1").unwrap();
        let left  = client.register_output_audio_port("output2").unwrap();

        // create a channel pair we can use to communicate with
        let (tx, rx) = mpsc::sync_channel(1);

        // create a client, set it up as an audio processing handler
        let handler = AudioHandler::new(SimpleClient::compute_sine(0.2), right, left, rx);
        client.set_process_handler(handler).unwrap();

        Ok(SimpleClient {
            client: client,
            sender: tx,
        })
    }

examples/connect.rs (line 40)

    fn new(servername: Option<String>) -> Result<Self, jack::status::Status> {
        // we don't want to start a server if none is already started
        let opts   = jack::options::NO_START_SERVER;
        let myname = "connector";
        let client = match servername {
            None             => jack::Client::open(myname, opts),
            Some(servername) => jack::Client::open_connection_to(myname, &*servername, opts),
        };

        let client = match client {
            Ok((cl, _)) => cl,
            Err(code)   => return Err(code)
        };

        // create our channel to communicate with the handler
        let (tx, rx) = mpsc::channel();

        // create the handler and give it the transmission end of the channel
        let handler = ConnectorHandler { outgoing: tx };

        // create an instance of the Connector, then set up the handler
        let mut conn = Connector { client: client, incoming: rx };
        conn.client.set_metadata_handler(handler).unwrap();

        Ok(conn)
    }

examples/midi_sine.rs (line 163)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);


    let mut c = jack::Client::open("midi_sine", jack::options::NO_START_SERVER).unwrap().0;
    let i = c.register_input_midi_port("midi_in").unwrap();
    let o = c.register_output_audio_port("audio_out").unwrap();

    let (tx, rx) = mpsc::sync_channel(1);

    let handler = AudioHandler::new(i, o, rx);
    c.set_process_handler(handler).unwrap();

    let handler = MetadataHandler::new(tx);
    c.set_metadata_handler(handler).unwrap();

    c.activate().unwrap();

    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }
    println!("tearing down");
    c.close().unwrap();
}

examples/thru.rs (line 63)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);

    let mut jack_client =
        jack::Client::open("testclient", jack::options::NO_START_SERVER).unwrap().0;

    println!("client created named: {}", jack_client.get_name());

    // 2 in, 2 out
    let input1 = jack_client.register_input_audio_port("input1").unwrap();
    let input2 = jack_client.register_input_audio_port("input2").unwrap();
    let output1 = jack_client.register_output_audio_port("output1").unwrap();
    let output2 = jack_client.register_output_audio_port("output2").unwrap();

    let handler = Connector::new(vec![input1, input2], vec![output1, output2]);
    jack_client.set_process_handler(handler).unwrap();

    // start everything up
    jack_client.activate().unwrap();

    // wait to get a SIGINT
    // jack will do all of its magic in other threads
    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }

    // now we can clean everything up
    // the library doesn't handle this for us because it would be rather confusing, especially
    // given how the underlying jack api actually works
    println!("tearing down");

    // closing the client unregisters all of the ports
    // unregistering the ports after the client is closed is an error
    jack_client.close().unwrap();
}

pub fn open_connection_to( clientname: &str, servername: &str, opts: Options, ) -> Result<(Self, String), Status>

Attempts to open a client connecting to a server with a specified name

Examples found in repository

examples/connect.rs (line 41)

    fn new(servername: Option<String>) -> Result<Self, jack::status::Status> {
        // we don't want to start a server if none is already started
        let opts   = jack::options::NO_START_SERVER;
        let myname = "connector";
        let client = match servername {
            None             => jack::Client::open(myname, opts),
            Some(servername) => jack::Client::open_connection_to(myname, &*servername, opts),
        };

        let client = match client {
            Ok((cl, _)) => cl,
            Err(code)   => return Err(code)
        };

        // create our channel to communicate with the handler
        let (tx, rx) = mpsc::channel();

        // create the handler and give it the transmission end of the channel
        let handler = ConnectorHandler { outgoing: tx };

        // create an instance of the Connector, then set up the handler
        let mut conn = Connector { client: client, incoming: rx };
        conn.client.set_metadata_handler(handler).unwrap();

        Ok(conn)
    }

pub fn get_name(&self) -> String

Returns the actual name of the client. This is useful when USE_EXACT_NAME is not specified, because the jack server might assign some other name to your client to ensure that it is unique.

Returns a copy of the actual string returned the JACK C API

Examples found in repository

examples/thru.rs (line 65)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);

    let mut jack_client =
        jack::Client::open("testclient", jack::options::NO_START_SERVER).unwrap().0;

    println!("client created named: {}", jack_client.get_name());

    // 2 in, 2 out
    let input1 = jack_client.register_input_audio_port("input1").unwrap();
    let input2 = jack_client.register_input_audio_port("input2").unwrap();
    let output1 = jack_client.register_output_audio_port("output1").unwrap();
    let output2 = jack_client.register_output_audio_port("output2").unwrap();

    let handler = Connector::new(vec![input1, input2], vec![output1, output2]);
    jack_client.set_process_handler(handler).unwrap();

    // start everything up
    jack_client.activate().unwrap();

    // wait to get a SIGINT
    // jack will do all of its magic in other threads
    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }

    // now we can clean everything up
    // the library doesn't handle this for us because it would be rather confusing, especially
    // given how the underlying jack api actually works
    println!("tearing down");

    // closing the client unregisters all of the ports
    // unregistering the ports after the client is closed is an error
    jack_client.close().unwrap();
}

pub fn register_input_audio_port( &mut self, name: &str, ) -> Result<InputPortHandle<DefaultAudioSample>, Status>

Helper function which registers an input audio port with a given name.

Examples found in repository

examples/thru.rs (line 68)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);

    let mut jack_client =
        jack::Client::open("testclient", jack::options::NO_START_SERVER).unwrap().0;

    println!("client created named: {}", jack_client.get_name());

    // 2 in, 2 out
    let input1 = jack_client.register_input_audio_port("input1").unwrap();
    let input2 = jack_client.register_input_audio_port("input2").unwrap();
    let output1 = jack_client.register_output_audio_port("output1").unwrap();
    let output2 = jack_client.register_output_audio_port("output2").unwrap();

    let handler = Connector::new(vec![input1, input2], vec![output1, output2]);
    jack_client.set_process_handler(handler).unwrap();

    // start everything up
    jack_client.activate().unwrap();

    // wait to get a SIGINT
    // jack will do all of its magic in other threads
    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }

    // now we can clean everything up
    // the library doesn't handle this for us because it would be rather confusing, especially
    // given how the underlying jack api actually works
    println!("tearing down");

    // closing the client unregisters all of the ports
    // unregistering the ports after the client is closed is an error
    jack_client.close().unwrap();
}

pub fn register_input_midi_port( &mut self, name: &str, ) -> Result<InputPortHandle<MidiEvent>, Status>

Helper function which registers an input midi port with a given name.

Examples found in repository

examples/midi_sine.rs (line 164)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);


    let mut c = jack::Client::open("midi_sine", jack::options::NO_START_SERVER).unwrap().0;
    let i = c.register_input_midi_port("midi_in").unwrap();
    let o = c.register_output_audio_port("audio_out").unwrap();

    let (tx, rx) = mpsc::sync_channel(1);

    let handler = AudioHandler::new(i, o, rx);
    c.set_process_handler(handler).unwrap();

    let handler = MetadataHandler::new(tx);
    c.set_metadata_handler(handler).unwrap();

    c.activate().unwrap();

    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }
    println!("tearing down");
    c.close().unwrap();
}

pub fn register_output_audio_port( &mut self, name: &str, ) -> Result<OutputPortHandle<DefaultAudioSample>, Status>

Helper function which registers an output audio port with a given name.

Examples found in repository

examples/simple_client.rs (line 120)

    fn new() -> Result<Self, jack::status::Status> {
        let client = jack::Client::open("simple", jack::options::NO_START_SERVER);
        let mut client = match client {
            Ok((client, _)) => client,
            Err(code)       => return Err(code),
        };

        // get some ports
        let right = client.register_output_audio_port("output1").unwrap();
        let left  = client.register_output_audio_port("output2").unwrap();

        // create a channel pair we can use to communicate with
        let (tx, rx) = mpsc::sync_channel(1);

        // create a client, set it up as an audio processing handler
        let handler = AudioHandler::new(SimpleClient::compute_sine(0.2), right, left, rx);
        client.set_process_handler(handler).unwrap();

        Ok(SimpleClient {
            client: client,
            sender: tx,
        })
    }

examples/midi_sine.rs (line 165)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);


    let mut c = jack::Client::open("midi_sine", jack::options::NO_START_SERVER).unwrap().0;
    let i = c.register_input_midi_port("midi_in").unwrap();
    let o = c.register_output_audio_port("audio_out").unwrap();

    let (tx, rx) = mpsc::sync_channel(1);

    let handler = AudioHandler::new(i, o, rx);
    c.set_process_handler(handler).unwrap();

    let handler = MetadataHandler::new(tx);
    c.set_metadata_handler(handler).unwrap();

    c.activate().unwrap();

    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }
    println!("tearing down");
    c.close().unwrap();
}

examples/thru.rs (line 70)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);

    let mut jack_client =
        jack::Client::open("testclient", jack::options::NO_START_SERVER).unwrap().0;

    println!("client created named: {}", jack_client.get_name());

    // 2 in, 2 out
    let input1 = jack_client.register_input_audio_port("input1").unwrap();
    let input2 = jack_client.register_input_audio_port("input2").unwrap();
    let output1 = jack_client.register_output_audio_port("output1").unwrap();
    let output2 = jack_client.register_output_audio_port("output2").unwrap();

    let handler = Connector::new(vec![input1, input2], vec![output1, output2]);
    jack_client.set_process_handler(handler).unwrap();

    // start everything up
    jack_client.activate().unwrap();

    // wait to get a SIGINT
    // jack will do all of its magic in other threads
    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }

    // now we can clean everything up
    // the library doesn't handle this for us because it would be rather confusing, especially
    // given how the underlying jack api actually works
    println!("tearing down");

    // closing the client unregisters all of the ports
    // unregistering the ports after the client is closed is an error
    jack_client.close().unwrap();
}

pub fn unregister_port<T: Port>(&mut self, port: T) -> Result<(), Status>

Removes the port from the client and invalidates the port and all Handles relating to the port.

The server disconnects everything that was previously connected to the port.

pub fn get_port_by_name(&self, name: &str) -> Option<UnknownPortHandle>

pub fn get_port_by_id(&self, id: PortId) -> Option<UnknownPortHandle>

Examples found in repository

examples/connect.rs (line 76)

    fn wait_and_shutdown(self) {
        let (a, b, stat) = self.incoming.recv().unwrap();
        let n1 = self.client.get_port_by_id(a).unwrap().get_name();
        let n2 = self.client.get_port_by_id(b).unwrap().get_name();

        match stat {
            jack::PortConnectStatus::PortsConnected =>
                println!("ports connected: {} and {}", n1, n2),

            jack::PortConnectStatus::PortsDisconnected =>
                println!("ports disconnected: {} and {}", n1, n2)
        }
    }

pub fn connect_ports(&mut self, port1: &str, port2: &str) -> Result<(), Status>

Attempts to connect the ports with the given names Note that this method calls directly into the jack api. It does not perform lookups for the names before making the call

Examples found in repository

examples/connect.rs (line 67)

    fn connect(&mut self, port1: &str, port2: &str) -> Result<(), jack::status::Status> {
        self.client.connect_ports(port1, port2)
    }

pub fn disconnect_ports( &mut self, port1: &str, port2: &str, ) -> Result<(), Status>

Attempts to disconnect the ports with the given names Note that this method calls directly into the jack api. It does not perform lookups for the names before making the call

Examples found in repository

examples/connect.rs (line 71)

    fn disconnect(&mut self, port1: &str, port2: &str) -> Result<(), jack::status::Status> {
        self.client.disconnect_ports(port1, port2)
    }

pub fn set_process_handler<T: ProcessHandler + 'a>( &mut self, handler: T, ) -> Result<(), Status>

Set the client’s process callback handler. The client takes ownership of the handler, so be sure to set up any messaging queues before passing the handler off to the client See the docs for the ProcessHandler struct for more details

Examples found in repository

examples/simple_client.rs (line 128)

    fn new() -> Result<Self, jack::status::Status> {
        let client = jack::Client::open("simple", jack::options::NO_START_SERVER);
        let mut client = match client {
            Ok((client, _)) => client,
            Err(code)       => return Err(code),
        };

        // get some ports
        let right = client.register_output_audio_port("output1").unwrap();
        let left  = client.register_output_audio_port("output2").unwrap();

        // create a channel pair we can use to communicate with
        let (tx, rx) = mpsc::sync_channel(1);

        // create a client, set it up as an audio processing handler
        let handler = AudioHandler::new(SimpleClient::compute_sine(0.2), right, left, rx);
        client.set_process_handler(handler).unwrap();

        Ok(SimpleClient {
            client: client,
            sender: tx,
        })
    }

examples/midi_sine.rs (line 170)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);


    let mut c = jack::Client::open("midi_sine", jack::options::NO_START_SERVER).unwrap().0;
    let i = c.register_input_midi_port("midi_in").unwrap();
    let o = c.register_output_audio_port("audio_out").unwrap();

    let (tx, rx) = mpsc::sync_channel(1);

    let handler = AudioHandler::new(i, o, rx);
    c.set_process_handler(handler).unwrap();

    let handler = MetadataHandler::new(tx);
    c.set_metadata_handler(handler).unwrap();

    c.activate().unwrap();

    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }
    println!("tearing down");
    c.close().unwrap();
}

examples/thru.rs (line 74)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);

    let mut jack_client =
        jack::Client::open("testclient", jack::options::NO_START_SERVER).unwrap().0;

    println!("client created named: {}", jack_client.get_name());

    // 2 in, 2 out
    let input1 = jack_client.register_input_audio_port("input1").unwrap();
    let input2 = jack_client.register_input_audio_port("input2").unwrap();
    let output1 = jack_client.register_output_audio_port("output1").unwrap();
    let output2 = jack_client.register_output_audio_port("output2").unwrap();

    let handler = Connector::new(vec![input1, input2], vec![output1, output2]);
    jack_client.set_process_handler(handler).unwrap();

    // start everything up
    jack_client.activate().unwrap();

    // wait to get a SIGINT
    // jack will do all of its magic in other threads
    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }

    // now we can clean everything up
    // the library doesn't handle this for us because it would be rather confusing, especially
    // given how the underlying jack api actually works
    println!("tearing down");

    // closing the client unregisters all of the ports
    // unregistering the ports after the client is closed is an error
    jack_client.close().unwrap();
}

pub fn set_metadata_handler<T: MetadataHandler + 'a>( &mut self, handler: T, ) -> Result<(), Status>

Set the client’s sample rate change handler.

Examples found in repository

examples/connect.rs (line 57)

    fn new(servername: Option<String>) -> Result<Self, jack::status::Status> {
        // we don't want to start a server if none is already started
        let opts   = jack::options::NO_START_SERVER;
        let myname = "connector";
        let client = match servername {
            None             => jack::Client::open(myname, opts),
            Some(servername) => jack::Client::open_connection_to(myname, &*servername, opts),
        };

        let client = match client {
            Ok((cl, _)) => cl,
            Err(code)   => return Err(code)
        };

        // create our channel to communicate with the handler
        let (tx, rx) = mpsc::channel();

        // create the handler and give it the transmission end of the channel
        let handler = ConnectorHandler { outgoing: tx };

        // create an instance of the Connector, then set up the handler
        let mut conn = Connector { client: client, incoming: rx };
        conn.client.set_metadata_handler(handler).unwrap();

        Ok(conn)
    }

examples/midi_sine.rs (line 173)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);


    let mut c = jack::Client::open("midi_sine", jack::options::NO_START_SERVER).unwrap().0;
    let i = c.register_input_midi_port("midi_in").unwrap();
    let o = c.register_output_audio_port("audio_out").unwrap();

    let (tx, rx) = mpsc::sync_channel(1);

    let handler = AudioHandler::new(i, o, rx);
    c.set_process_handler(handler).unwrap();

    let handler = MetadataHandler::new(tx);
    c.set_metadata_handler(handler).unwrap();

    c.activate().unwrap();

    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }
    println!("tearing down");
    c.close().unwrap();
}

pub fn activate(&self) -> Result<(), Status>

tells the JACK server that the client is read to start processing audio This will initiate callbacks into the CallbackHandler provided.

Examples found in repository

examples/connect.rs (line 63)

    fn activate(&mut self) -> Result<(), jack::status::Status> {
        self.client.activate()
    }

examples/simple_client.rs (line 137)

    fn activate(&mut self) -> Result<(), jack::status::Status> {
        self.client.activate()
    }

examples/midi_sine.rs (line 175)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);


    let mut c = jack::Client::open("midi_sine", jack::options::NO_START_SERVER).unwrap().0;
    let i = c.register_input_midi_port("midi_in").unwrap();
    let o = c.register_output_audio_port("audio_out").unwrap();

    let (tx, rx) = mpsc::sync_channel(1);

    let handler = AudioHandler::new(i, o, rx);
    c.set_process_handler(handler).unwrap();

    let handler = MetadataHandler::new(tx);
    c.set_metadata_handler(handler).unwrap();

    c.activate().unwrap();

    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }
    println!("tearing down");
    c.close().unwrap();
}

examples/thru.rs (line 77)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);

    let mut jack_client =
        jack::Client::open("testclient", jack::options::NO_START_SERVER).unwrap().0;

    println!("client created named: {}", jack_client.get_name());

    // 2 in, 2 out
    let input1 = jack_client.register_input_audio_port("input1").unwrap();
    let input2 = jack_client.register_input_audio_port("input2").unwrap();
    let output1 = jack_client.register_output_audio_port("output1").unwrap();
    let output2 = jack_client.register_output_audio_port("output2").unwrap();

    let handler = Connector::new(vec![input1, input2], vec![output1, output2]);
    jack_client.set_process_handler(handler).unwrap();

    // start everything up
    jack_client.activate().unwrap();

    // wait to get a SIGINT
    // jack will do all of its magic in other threads
    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }

    // now we can clean everything up
    // the library doesn't handle this for us because it would be rather confusing, especially
    // given how the underlying jack api actually works
    println!("tearing down");

    // closing the client unregisters all of the ports
    // unregistering the ports after the client is closed is an error
    jack_client.close().unwrap();
}

pub fn close(&mut self) -> Result<(), &str>

Disconnects the client from the JACK server. This will also disconnect and destroy any of the ports which the client registered

Examples found in repository

examples/simple_client.rs (line 159)

    fn run(mut self) {
        let mut i = 0;
        while RUNNING.load(atomic::Ordering::SeqCst) {
            let newsine = SimpleClient::compute_sine(i as f32 / 10.0);

            match self.sender.send(newsine) {
                Ok(_)  => (),
                Err(_) => (),
            };

            i += 1;
            if i > 10 {
                i = 0
            }

            thread::sleep(Duration::from_millis(1000));
        }

        println!("tearing down");
        self.client.close().unwrap();
    }

examples/midi_sine.rs (line 181)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);


    let mut c = jack::Client::open("midi_sine", jack::options::NO_START_SERVER).unwrap().0;
    let i = c.register_input_midi_port("midi_in").unwrap();
    let o = c.register_output_audio_port("audio_out").unwrap();

    let (tx, rx) = mpsc::sync_channel(1);

    let handler = AudioHandler::new(i, o, rx);
    c.set_process_handler(handler).unwrap();

    let handler = MetadataHandler::new(tx);
    c.set_metadata_handler(handler).unwrap();

    c.activate().unwrap();

    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }
    println!("tearing down");
    c.close().unwrap();
}

examples/thru.rs (line 92)

fn main() {
    // register a signal handler (see comments at top of file)
    let action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigint),
        signal::SaFlags::empty(),
        signal::SigSet::empty());

    unsafe { signal::sigaction(signal::Signal::SIGINT, &action) }.unwrap();

    // set our global atomic to true
    RUNNING.store(true, atomic::Ordering::SeqCst);

    let mut jack_client =
        jack::Client::open("testclient", jack::options::NO_START_SERVER).unwrap().0;

    println!("client created named: {}", jack_client.get_name());

    // 2 in, 2 out
    let input1 = jack_client.register_input_audio_port("input1").unwrap();
    let input2 = jack_client.register_input_audio_port("input2").unwrap();
    let output1 = jack_client.register_output_audio_port("output1").unwrap();
    let output2 = jack_client.register_output_audio_port("output2").unwrap();

    let handler = Connector::new(vec![input1, input2], vec![output1, output2]);
    jack_client.set_process_handler(handler).unwrap();

    // start everything up
    jack_client.activate().unwrap();

    // wait to get a SIGINT
    // jack will do all of its magic in other threads
    while RUNNING.load(atomic::Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(1000));
    }

    // now we can clean everything up
    // the library doesn't handle this for us because it would be rather confusing, especially
    // given how the underlying jack api actually works
    println!("tearing down");

    // closing the client unregisters all of the ports
    // unregistering the ports after the client is closed is an error
    jack_client.close().unwrap();
}