1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Rust bindings for JACK, a real-time audio and midi library.
//!
//! # Server
//!
//! JACK provides a high priority server to manipulate audio and midi across applications. The rust
//! jack crate does not provide server creation functionality, so a server has to be set up with the
//! `jackd` commandline tool, `qjackctl` the gui tool, or another method.
//!
//! # Client
//!
//! Typically, applications connect clients to the server. For the rust jack crate, a connection can
//! be made with `client::Client::new`, which returns a `client::Client`.
//!
//! The `Client` can query the server for information, register ports, and manage connections for
//! ports.
//!
//! To commence processing audio/midi and other information in real-time, rust jack provides the
//! `client::AsyncClient::new`, which consumes a `Client` an object that implements
//! `NotificationHandler` and an object that implements `ProcessHandler` and returns a
//! `AsyncClient`. `AsyncClient` processes the data in real-time with the provided handlers.
//!
//! # Port
//!
//! A `Client` may obtain port information through the `Client::port_by_id` and
//! `Client::port_by_name` methods. These ports can be used to manage connections or to obtain port
//! metadata, though their port data (audio buffers and midi buffers) cannot be accessed safely.
//!
//! Ports can be registered with the `Client::register_port` method. This requires a `PortSpec`. The
//! jack crate comes with common specs such as `AudioInSpec`, `AudioOutSpec`, `MidiInSpec`, and
//! `MidiOutSpec` under the `port` mod.
//!
//! To access the data of registered ports, use wrappers that are valid when a `ProcessScope` is
//! present. The ones provided by the rust jack crate are `AudioInPort`, `AudioOutPort`,
//! `MidiInPort`, and `MidiOutPort`, all of which are under the `port` mod. It is also possible to
//! access the data without wrapping the newly registered `Port<PortSpec>` by using the
//! `Port::buffer` method, but this returns a void pointer and is unsafe.
#[macro_use]
extern crate bitflags;
extern crate jack_sys;
#[macro_use]
extern crate lazy_static;
extern crate libc;


/// Create and manage client connections to a JACK server.
pub mod client;

/// Create and manage JACK ring buffers.
pub mod ringbuffer;

/// Control error and info logging from JACK.
pub mod logging;

/// Enum types in jack.
pub mod jack_enums;

mod jack_utils;

/// Types for safely interacting with port data from JACK.
pub mod port;

/// Platform independent types.
pub mod primitive_types;

/// Return JACK's current system time in microseconds, using the JACK
/// clock source.
pub fn get_time() -> primitive_types::JackTime {
    unsafe { jack_sys::jack_get_time() }
}

/// Contains every trait defined in the jack crate.
pub mod traits {
    pub use client::{ProcessHandler, NotificationHandler};
    pub use port::PortSpec;
}

/// Contains most functionality needed to interact with JACK.
pub mod prelude {
    pub use primitive_types::{JackFrames, JackTime, JackPortId};
    pub use jack_enums::{JackErr, JackControl, LatencyType};
    pub use client::{AsyncClient, Client, CycleTimes, NotificationHandler, ProcessHandler,
                     ClosureProcessHandler, ProcessScope};
    pub use client::CLIENT_NAME_SIZE;
    pub use client::{ClientOptions, ClientStatus, client_options, client_status};
    pub use ringbuffer::{RingBuffer, RingBufferReader, RingBufferWriter};
    pub use port::{AudioInPort, AudioInSpec, AudioOutPort, AudioOutSpec, MidiInPort, MidiInSpec,
                   MidiIter, MidiOutPort, MidiOutSpec, Port, RawMidi, Unowned, UnownedPort};
    pub use port::{PORT_NAME_SIZE, PORT_TYPE_SIZE};
    pub use port::{PortFlags, port_flags};
    pub use port::PortSpec;
    pub use logging::{set_info_callback, get_info_callback, reset_info_callback,
                      set_error_callback, get_error_callback, reset_error_callback};
}

#[cfg(test)]
mod test;