jack.c

fn jack_activate jack_client_close jack_client_name_size jack_client_open jack_client_thread_id jack_connect jack_cpu_load jack_cycle_signal jack_cycle_wait jack_deactivate jack_disconnect jack_frame_time jack_frames_since_cycle_start jack_frames_to_time jack_free jack_get_buffer_size jack_get_client_name jack_get_client_pid jack_get_current_transport_frame jack_get_ports jack_get_sample_rate jack_get_time jack_get_version jack_get_version_string jack_is_realtime jack_last_frame_time jack_midi_clear_buffer jack_midi_event_get jack_midi_event_reserve jack_midi_event_write jack_midi_get_event_count jack_midi_get_lost_event_count jack_midi_max_event_size jack_on_info_shutdown jack_on_shutdown jack_port_by_id jack_port_by_name jack_port_connected jack_port_connected_to jack_port_disconnect jack_port_ensure_monitor jack_port_flags jack_port_get_aliases jack_port_get_all_connections jack_port_get_buffer jack_port_get_connections jack_port_get_latency_range jack_port_is_mine jack_port_monitoring_input jack_port_name jack_port_name_size jack_port_register jack_port_request_monitor jack_port_request_monitor_by_name jack_port_set_alias jack_port_set_latency_range jack_port_set_name jack_port_short_name jack_port_type jack_port_type_get_buffer_size jack_port_type_id jack_port_type_size jack_port_unregister jack_port_unset_alias jack_port_uuid jack_recompute_total_latencies jack_release_timebase jack_set_buffer_size jack_set_buffer_size_callback jack_set_client_registration_callback jack_set_error_function jack_set_freewheel jack_set_freewheel_callback jack_set_graph_order_callback jack_set_info_function jack_set_latency_callback jack_set_port_connect_callback jack_set_port_registration_callback jack_set_port_rename_callback jack_set_process_callback jack_set_process_thread jack_set_sample_rate_callback jack_set_sync_callback jack_set_sync_timeout jack_set_thread_init_callback jack_set_timebase_callback jack_set_xrun_callback jack_time_to_frames jack_transport_locate jack_transport_query jack_transport_reposition jack_transport_start jack_transport_stop

Functions 93

fnvoid jack_get_version(int * major, int * minor, int * micro, int * proto)Thin extern(C) bindings to libjack.

fnconst(char) * jack_get_version_string()

jack_client_t * jack_client_open(const(char) *  client_name,
                                 jack_options_t options,
                                 jack_status_t *  status, ...)

fnint jack_client_close(jack_client_t * client)

fnint jack_client_name_size()

fnconst(char) * jack_get_client_name(jack_client_t * client)

fnint jack_activate(jack_client_t * client)

fnint jack_deactivate(jack_client_t * client)

fnint jack_get_client_pid(const(char) * name)

fnjack_native_thread_t jack_client_thread_id(jack_client_t * client)

fnint jack_is_realtime(jack_client_t * client)

fnjack_nframes_t jack_cycle_wait(jack_client_t * client)

fnvoid jack_cycle_signal(jack_client_t * client, int status)

int jack_set_process_thread(jack_client_t *  client,
                             JackThreadCallback thread_callback,
                             void *  arg)

int jack_set_thread_init_callback(jack_client_t *  client,
                                   JackThreadInitCallback cb,
                                   void *  arg)

void jack_on_shutdown(jack_client_t *  client,
                       JackShutdownCallback cb,
                       void *  arg)

void jack_on_info_shutdown(jack_client_t *  client,
                            JackInfoShutdownCallback cb,
                            void *  arg)

int jack_set_process_callback(jack_client_t *  client,
                               JackProcessCallback cb,
                               void *  arg)

int jack_set_freewheel_callback(jack_client_t *  client,
                                 JackFreewheelCallback cb,
                                 void *  arg)

int jack_set_buffer_size_callback(jack_client_t *  client,
                                   JackBufferSizeCallback cb,
                                   void *  arg)

int jack_set_sample_rate_callback(jack_client_t *  client,
                                   JackSampleRateCallback cb,
                                   void *  arg)

int jack_set_client_registration_callback(jack_client_t *  client,
                                           JackClientRegistrationCallback cb,
                                           void *  arg)

int jack_set_port_registration_callback(jack_client_t *  client,
                                         JackPortRegistrationCallback cb,
                                         void *  arg)

int jack_set_port_connect_callback(jack_client_t *  client,
                                    JackPortConnectCallback cb,
                                    void *  arg)

int jack_set_port_rename_callback(jack_client_t *  client,
                                   JackPortRenameCallback cb,
                                   void *  arg)

int jack_set_graph_order_callback(jack_client_t *  client,
                                   JackGraphOrderCallback cb,
                                   void *  arg)

int jack_set_xrun_callback(jack_client_t *  client,
                            JackXRunCallback cb,
                            void *  arg)

int jack_set_latency_callback(jack_client_t *  client,
                               JackLatencyCallback cb,
                               void *  arg)

fnint jack_set_freewheel(jack_client_t * client, int onoff)

fnint jack_set_buffer_size(jack_client_t * client, jack_nframes_t nframes)

fnjack_nframes_t jack_get_sample_rate(jack_client_t * client)

fnjack_nframes_t jack_get_buffer_size(jack_client_t * client)

fnfloat jack_cpu_load(jack_client_t * client)

jack_port_t * jack_port_register(jack_client_t *  client,
                                 const(char) *  port_name,
                                 const(char) *  port_type,
                                 ulong  flags,
                                 ulong  buffer_size)

fnint jack_port_unregister(jack_client_t * client, jack_port_t * port)

fnvoid * jack_port_get_buffer(jack_port_t * port, jack_nframes_t nframes)

fnjack_uuid_t jack_port_uuid(const(jack_port_t) * port)

fnconst(char) * jack_port_name(const(jack_port_t) * port)

fnconst(char) * jack_port_short_name(const(jack_port_t) * port)

fnint jack_port_flags(const(jack_port_t) * port)

fnconst(char) * jack_port_type(const(jack_port_t) * port)

fnjack_port_type_id_t jack_port_type_id(const(jack_port_t) * port)

fnint jack_port_is_mine(const(jack_client_t) * client, const(jack_port_t) * port)

fnint jack_port_connected(const(jack_port_t) * port)

fnint jack_port_connected_to(const(jack_port_t) * port, const(char) * port_name)

fnconst(char) * * jack_port_get_connections(const(jack_port_t) * port)

const(char) * * jack_port_get_all_connections(const(jack_client_t) *  client,
                                             const(jack_port_t) *  port)

fnint jack_port_set_name(jack_port_t * port, const(char) * port_name)

fnint jack_port_set_alias(jack_port_t * port, const(char) * alias_)

fnint jack_port_unset_alias(jack_port_t * port, const(char) * alias_)

fnint jack_port_get_aliases(const(jack_port_t) * port, const(char) * * aliases)

fnint jack_port_request_monitor(jack_port_t * port, int onoff)

int jack_port_request_monitor_by_name(jack_client_t *  client,
                                       const(char) *  port_name,
                                       int  onoff)

fnint jack_port_ensure_monitor(jack_port_t * port, int onoff)

fnint jack_port_monitoring_input(jack_port_t * port)

int jack_connect(jack_client_t *  client,
                  const(char) *  source_port,
                  const(char) *  destination_port)

int jack_disconnect(jack_client_t *  client,
                     const(char) *  source_port,
                     const(char) *  destination_port)

fnint jack_port_disconnect(jack_client_t * client, jack_port_t * port)

fnint jack_port_name_size()

fnint jack_port_type_size()

size_t jack_port_type_get_buffer_size(jack_client_t *  client,
                                       const(char) *  port_type)

void jack_port_get_latency_range(jack_port_t *  port,
                                  jack_latency_callback_mode_t mode,
                                  jack_latency_range_t *  range)

void jack_port_set_latency_range(jack_port_t *  port,
                                  jack_latency_callback_mode_t mode,
                                  jack_latency_range_t *  range)

fnint jack_recompute_total_latencies(jack_client_t * client)

const(char) * * jack_get_ports(jack_client_t *  client,
                              const(char) *  port_name_pattern,
                              const(char) *  type_name_pattern,
                              ulong  flags)

fnjack_port_t * jack_port_by_name(jack_client_t * client, const(char) * port_name)

fnjack_port_t * jack_port_by_id(jack_client_t * client, jack_port_id_t port_id)

fnjack_nframes_t jack_frames_since_cycle_start(const(jack_client_t) * client)

fnjack_nframes_t jack_frame_time(const(jack_client_t) * client)

fnjack_nframes_t jack_last_frame_time(const(jack_client_t) * client)

fnjack_time_t jack_frames_to_time(const(jack_client_t) * client, jack_nframes_t frames)

fnjack_nframes_t jack_time_to_frames(const(jack_client_t) * client, jack_time_t time)

fnjack_time_t jack_get_time()

fnint jack_release_timebase(jack_client_t * client)

int jack_set_sync_callback(jack_client_t *  client,
                            JackSyncCallback cb,
                            void *  arg)

fnint jack_set_sync_timeout(jack_client_t * client, jack_time_t timeout)

int jack_set_timebase_callback(jack_client_t *  client,
                                int  conditional,
                                JackTimebaseCallback cb,
                                void *  arg)

fnint jack_transport_locate(jack_client_t * client, jack_nframes_t frame)

jack_transport_state_t jack_transport_query(const(jack_client_t) *  client,
                                             jack_position_t *  pos)

fnjack_nframes_t jack_get_current_transport_frame(const(jack_client_t) * client)

fnint jack_transport_reposition(jack_client_t * client, const(jack_position_t) * pos)

fnvoid jack_transport_start(jack_client_t * client)

fnvoid jack_transport_stop(jack_client_t * client)

fnuint jack_midi_get_event_count(void * port_buffer)

int jack_midi_event_get(jack_midi_event_t *  event,
                          void *  port_buffer,
                          uint  event_index)

fnvoid jack_midi_clear_buffer(void * port_buffer)

fnsize_t jack_midi_max_event_size(void * port_buffer)

jack_midi_data_t * jack_midi_event_reserve(void *  port_buffer,
                                           jack_nframes_t time,
                                           size_t data_size)

int jack_midi_event_write(void *  port_buffer,
                           jack_nframes_t time,
                           const(jack_midi_data_t) *  data,
                           size_t data_size)

fnuint jack_midi_get_lost_event_count(void * port_buffer)

fnvoid jack_set_error_function(JackErrorCallback cb)

fnvoid jack_set_info_function(JackInfoCallback cb)

fnvoid jack_free(void * ptr)