diff --git a/src/jacklib.py b/src/jacklib.py index 3bf7e51..f0ebaa4 100644 --- a/src/jacklib.py +++ b/src/jacklib.py @@ -72,6 +72,8 @@ jack_unique_t = c_uint64 jack_position_bits_t = c_enum # Optional struct jack_position_t fields. jack_transport_bits_t = c_enum # Optional struct jack_transport_info_t fields jack_midi_data_t = c_uchar +jack_session_event_type_t = c_enum # JackSessionEventType +jack_session_flags_t = c_enum # JackSessionFlags # enum JackOptions JackNullOption = 0x00 @@ -132,6 +134,15 @@ JackTransportLoop = 0x4 JackTransportSMPTE = 0x8 JackTransportBBT = 0x10 +# enum JackSessionEventType +JackSessionSave = 1 +JackSessionSaveAndQuit = 2 +JackSessionSaveTemplate = 3 + +# enum JackSessionFlags +JackSessionSaveError = 0x01 +JackSessionNeedTerminal = 0x02 + # --------------------------------------------------------------------------------------------------------------------- # Structs @@ -193,6 +204,45 @@ class jack_midi_event_t(Structure): ("buffer", POINTER(jack_midi_data_t)) ] +class jack_session_event_t(Structure): + _fields_ = [ + ("type", jack_session_event_type_t), + ("session_dir", c_char_p), + ("client_uuid", c_char_p), + ("command_line", c_char_p), + ("flags", jack_session_flags_t), + ("future", c_uint32) + ] + +class jack_session_command_t(Structure): + _fields_ = [ + ("uuid", c_char_p), + ("client_name", c_char_p), + ("command", c_char_p), + ("flags", jack_session_flags_t) + ] + +# --------------------------------------------------------------------------------------------------------------------- +# Callbacks + +JackLatencyCallback = CFUNCTYPE(None, jack_latency_callback_mode_t, c_void_p) +JackProcessCallback = CFUNCTYPE(c_int, jack_nframes_t, c_void_p) +JackThreadInitCallback = CFUNCTYPE(None, c_void_p) +JackGraphOrderCallback = CFUNCTYPE(c_int, c_void_p) +JackXRunCallback = CFUNCTYPE(c_int, c_void_p) +JackBufferSizeCallback = CFUNCTYPE(c_int, jack_nframes_t, c_void_p) +JackSampleRateCallback = CFUNCTYPE(c_int, jack_nframes_t, c_void_p) +JackPortRegistrationCallback = CFUNCTYPE(None, jack_port_id_t, c_int, c_void_p) +JackClientRegistrationCallback = CFUNCTYPE(None, c_char_p, c_int, c_void_p) +JackPortConnectCallback = CFUNCTYPE(None, jack_port_id_t, jack_port_id_t, c_int, c_void_p) +JackFreewheelCallback = CFUNCTYPE(None, c_int, c_void_p) +JackThreadCallback = CFUNCTYPE(c_void_p, c_void_p) +JackShutdownCallback = CFUNCTYPE(None, c_void_p) +JackInfoShutdownCallback = CFUNCTYPE(None, jack_status_t, c_char_p, c_void_p) +JackSyncCallback = CFUNCTYPE(c_int, jack_transport_state_t, POINTER(jack_position_t), c_void_p) +JackTimebaseCallback = CFUNCTYPE(None, jack_transport_state_t, jack_nframes_t, POINTER(jack_position_t), c_int, c_void_p) +JackSessionCallback = CFUNCTYPE(None, jack_session_event_t, c_void_p) + # --------------------------------------------------------------------------------------------------------------------- # Functions @@ -269,15 +319,79 @@ def cycle_signal(client, status): jacklib.jack_cycle_signal.restype = None jacklib.jack_cycle_signal(client, status) -#def set_process_thread(client, thread_callback, arg=None): - #global ThreadCallback - #ThreadCallback = CFUNCTYPE(c_int, c_void_p)(thread_callback) - #jacklib.jack_set_process_thread.restype = c_int - #return jacklib.jack_set_process_thread(client) +def set_process_thread(client, thread_callback, arg): + jacklib.jack_set_process_thread.argtypes = [POINTER(jack_client_t), JackThreadCallback, c_void_p] + jacklib.jack_set_process_thread.restype = c_int + return jacklib.jack_set_process_thread(client, JackThreadCallback(thread_callback), arg) # Client Callbacks +def set_thread_init_callback(client, thread_init_callback, arg): + jacklib.jack_set_thread_init_callback.argtypes = [POINTER(jack_client_t), JackThreadInitCallback, c_void_p] + jacklib.jack_set_thread_init_callback.restype = c_int + return jacklib.jack_set_thread_init_callback(client, JackThreadInitCallback(thread_init_callback), arg) + +def on_shutdown(client, function, arg): + jacklib.jack_on_shutdown.argtypes = [POINTER(jack_client_t), JackShutdownCallback, c_void_p] + jacklib.jack_on_shutdown.restype = None + jacklib.jack_on_shutdown(client, JackShutdownCallback(function), arg) + +def on_info_shutdown(client, function, arg): + jacklib.jack_on_info_shutdown.argtypes = [POINTER(jack_client_t), JackInfoShutdownCallback, c_void_p] + jacklib.jack_on_info_shutdown.restype = None + jacklib.jack_on_info_shutdown(client, JackInfoShutdownCallback(function), arg) + +def set_process_callback(client, process_callback, arg): + jacklib.jack_set_process_callback.argtypes = [POINTER(jack_client_t), JackProcessCallback, c_void_p] + jacklib.jack_set_process_callback.restype = c_int + return jacklib.jack_set_process_callback(client, JackProcessCallback(process_callback), arg) + +def set_freewheel_callback(client, freewheel_callback, arg): + jacklib.jack_set_freewheel_callback.argtypes = [POINTER(jack_client_t), JackFreewheelCallback, c_void_p] + jacklib.jack_set_freewheel_callback.restype = c_int + return jacklib.jack_set_freewheel_callback(client, JackFreewheelCallback(freewheel_callback), arg) + +def set_buffer_size_callback(client, bufsize_callback, arg): + jacklib.jack_set_buffer_size_callback.argtypes = [POINTER(jack_client_t), JackBufferSizeCallback, c_void_p] + jacklib.jack_set_buffer_size_callback.restype = c_int + return jacklib.jack_set_buffer_size_callback(client, JackBufferSizeCallback(bufsize_callback), arg) + +def set_sample_rate_callback(client, srate_callback, arg): + jacklib.jack_set_sample_rate_callback.argtypes = [POINTER(jack_client_t), JackSampleRateCallback, c_void_p] + jacklib.jack_set_sample_rate_callback.restype = c_int + return jacklib.jack_set_sample_rate_callback(client, JackSampleRateCallback(srate_callback), arg) + +def set_client_registration_callback(client, registration_callback, arg): + jacklib.jack_set_client_registration_callback.argtypes = [POINTER(jack_client_t), JackClientRegistrationCallback, c_void_p] + jacklib.jack_set_client_registration_callback.restype = c_int + return jacklib.jack_set_client_registration_callback(client, JackClientRegistrationCallback(registration_callback), arg) + +def set_port_registration_callback(client, registration_callback, arg): + jacklib.jack_set_port_registration_callback.argtypes = [POINTER(jack_client_t), JackPortRegistrationCallback, c_void_p] + jacklib.jack_set_port_registration_callback.restype = c_int + return jacklib.jack_set_port_registration_callback(client, JackPortRegistrationCallback(registration_callback), arg) + +def set_port_connect_callback(client, connect_callback, arg): + jacklib.jack_set_port_connect_callback.argtypes = [POINTER(jack_client_t), JackPortConnectCallback, c_void_p] + jacklib.jack_set_port_connect_callback.restype = c_int + return jacklib.jack_set_port_connect_callback(client, JackPortConnectCallback(connect_callback), arg) + +def set_graph_order_callback(client, graph_callback, arg): + jacklib.jack_set_graph_order_callback.argtypes = [POINTER(jack_client_t), JackGraphOrderCallback, c_void_p] + jacklib.jack_set_graph_order_callback.restype = c_int + return jacklib.jack_set_graph_order_callback(client, JackGraphOrderCallback(graph_callback), arg) + +def set_xrun_callback(client, xrun_callback, arg): + jacklib.jack_set_xrun_callback.argtypes = [POINTER(jack_client_t), JackXRunCallback, c_void_p] + jacklib.jack_set_xrun_callback.restype = c_int + return jacklib.jack_set_xrun_callback(client, JackXRunCallback(xrun_callback), arg) + +def set_latency_callback(client, latency_callback, arg): + jacklib.jack_set_latency_callback.argtypes = [POINTER(jack_client_t), JackLatencyCallback, c_void_p] + jacklib.jack_set_latency_callback.restype = c_int + return jacklib.jack_set_latency_callback(client, JackLatencyCallback(latency_callback), arg) + # Server Control @@ -563,83 +677,157 @@ def free(ptr): jacklib.jack_free.restype = None return jacklib.jack_free(ptr) -#int jack_release_timebase (jack_client_t *client) JACK_OPTIONAL_WEAK_EXPORT; -#int jack_set_sync_callback (jack_client_t *client, -#JackSyncCallback sync_callback, -#void *arg) JACK_OPTIONAL_WEAK_EXPORT; -#int jack_set_sync_timeout (jack_client_t *client, -#jack_time_t timeout) JACK_OPTIONAL_WEAK_EXPORT; -#int jack_set_timebase_callback (jack_client_t *client, -#int conditional, -#JackTimebaseCallback timebase_callback, -#void *arg) JACK_OPTIONAL_WEAK_EXPORT; -#int jack_transport_locate (jack_client_t *client, -#jack_nframes_t frame) JACK_OPTIONAL_WEAK_EXPORT; -#jack_transport_state_t jack_transport_query (const jack_client_t *client, -#jack_position_t *pos) JACK_OPTIONAL_WEAK_EXPORT; -#jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client) JACK_OPTIONAL_WEAK_EXPORT; -#int jack_transport_reposition (jack_client_t *client, -#const jack_position_t *pos) JACK_OPTIONAL_WEAK_EXPORT; -#void jack_transport_start (jack_client_t *client) JACK_OPTIONAL_WEAK_EXPORT; -#void jack_transport_stop (jack_client_t *client) JACK_OPTIONAL_WEAK_EXPORT; -#void jack_get_transport_info (jack_client_t *client, -#jack_transport_info_t *tinfo) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT; -#void jack_set_transport_info (jack_client_t *client, -#jack_transport_info_t *tinfo) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT; - -#jack_nframes_t -#jack_midi_get_event_count(void* port_buffer) JACK_OPTIONAL_WEAK_EXPORT; -#int -#jack_midi_event_get(jack_midi_event_t *event, - #void *port_buffer, - #uint32_t event_index) JACK_OPTIONAL_WEAK_EXPORT; -#void -#jack_midi_clear_buffer(void *port_buffer) JACK_OPTIONAL_WEAK_EXPORT; -#size_t -#jack_midi_max_event_size(void* port_buffer) JACK_OPTIONAL_WEAK_EXPORT; -#jack_midi_data_t* -#jack_midi_event_reserve(void *port_buffer, - #jack_nframes_t time, - #size_t data_size) JACK_OPTIONAL_WEAK_EXPORT; -#int -#jack_midi_event_write(void *port_buffer, - #jack_nframes_t time, - #const jack_midi_data_t *data, - #size_t data_size) JACK_OPTIONAL_WEAK_EXPORT; -#uint32_t -#jack_midi_get_lost_event_count(void *port_buffer) JACK_OPTIONAL_WEAK_EXPORT; - -#typedef void (*JackLatencyCallback)(jack_latency_callback_mode_t mode, void *arg); -#typedef int (*JackProcessCallback)(jack_nframes_t nframes, void *arg); -#typedef void (*JackThreadInitCallback)(void *arg); -#typedef int (*JackGraphOrderCallback)(void *arg); -#typedef int (*JackXRunCallback)(void *arg); -#typedef int (*JackBufferSizeCallback)(jack_nframes_t nframes, void *arg); -#typedef int (*JackSampleRateCallback)(jack_nframes_t nframes, void *arg); -#typedef void (*JackPortRegistrationCallback)(jack_port_id_t port, int register, void *arg); -#typedef void (*JackClientRegistrationCallback)(const char* name, int register, void *arg); -#typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg); -#typedef void (*JackFreewheelCallback)(int starting, void *arg); -#typedef void *(*JackThreadCallback)(void* arg); -#typedef void (*JackShutdownCallback)(void *arg); -#typedef void (*JackInfoShutdownCallback)(jack_status_t code, const char* reason, void *arg); -#typedef int (*JackSyncCallback)(jack_transport_state_t state, -#jack_position_t *pos, -#void *arg); -#typedef void (*JackTimebaseCallback)(jack_transport_state_t state, -#jack_nframes_t nframes, -#jack_position_t *pos, -#int new_pos, -#void *arg); - - - - - - - - +# Transport + +def release_timebase(client): + jacklib.jack_release_timebase.argtypes = [POINTER(jack_client_t)] + jacklib.jack_release_timebase.restype = c_int + return jacklib.jack_release_timebase(client) +def set_sync_callback(client, sync_callback, arg): + jacklib.jack_set_sync_callback.argtypes = [POINTER(jack_client_t), JackSyncCallback, c_void_p] + jacklib.jack_set_sync_callback.restype = c_int + return jacklib.jack_set_sync_callback(client, JackSyncCallback(sync_callback), arg) +def set_sync_timeout(client, timeout): + jacklib.jack_set_sync_timeout.argtypes = [POINTER(jack_client_t), jack_time_t] + jacklib.jack_set_sync_timeout.restype = c_int + return jacklib.jack_set_sync_timeout(client, timeout) +def set_timebase_callback(client, conditional, timebase_callback, arg): + jacklib.jack_set_timebase_callback.argtypes = [POINTER(jack_client_t), c_int, JackTimebaseCallback, c_void_p] + jacklib.jack_set_timebase_callback.restype = c_int + return jacklib.jack_set_timebase_callback(client, conditional, JackTimebaseCallback(timebase_callback), arg) + +def transport_locate(client, frame): + jacklib.jack_transport_locate.argtypes = [POINTER(jack_client_t), jack_nframes_t] + jacklib.jack_transport_locate.restype = c_int + return jacklib.jack_transport_locate(client, frame) + +def transport_query(client, pos): + jacklib.jack_transport_query.argtypes = [POINTER(jack_client_t), POINTER(jack_position_t)] + jacklib.jack_transport_query.restype = jack_transport_state_t + return jacklib.jack_transport_query(client, pos) + +def get_current_transport_frame(client): + jacklib.jack_get_current_transport_frame.argtypes = [POINTER(jack_client_t)] + jacklib.jack_get_current_transport_frame.restype = jack_nframes_t + return jacklib.jack_get_current_transport_frame(client) + +def transport_reposition(client, pos): + jacklib.jack_transport_reposition.argtypes = [POINTER(jack_client_t), POINTER(jack_position_t)] + jacklib.jack_transport_reposition.restype = c_int + return jacklib.jack_transport_reposition(client, pos) + +def transport_start(client): + jacklib.jack_transport_start.argtypes = [POINTER(jack_client_t)] + jacklib.jack_transport_start.restype = None + return jacklib.jack_transport_start(client) + +def transport_stop(client): + jacklib.jack_transport_stop.argtypes = [POINTER(jack_client_t)] + jacklib.jack_transport_stop.restype = None + return jacklib.jack_transport_stop(client) + +def get_transport_info(client, tinfo): + jacklib.jack_get_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)] + jacklib.jack_get_transport_info.restype = None + return jacklib.jack_get_transport_info(client, tinfo) + +def set_transport_info(client, tinfo): + jacklib.jack_set_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)] + jacklib.jack_set_transport_info.restype = None + return jacklib.jack_set_transport_info(client, tinfo) + + +# MIDI + +def midi_get_event_count(port_buffer): + jacklib.jack_midi_get_event_count.argtypes = [c_void_p] + jacklib.jack_midi_get_event_count.restype = jack_nframes_t + return jacklib.jack_midi_get_event_count(port_buffer) + +def midi_event_get(event, port_buffer, event_index): + jacklib.jack_midi_event_get.argtypes = [POINTER(jack_midi_event_t), c_void_p, c_uint32] + jacklib.jack_midi_event_get.restype = c_int + return jacklib.jack_midi_event_get(event, port_buffer, event_index) + +def midi_clear_buffer(port_buffer): + jacklib.jack_midi_clear_buffer.argtypes = [c_void_p] + jacklib.jack_midi_clear_buffer.restype = None + return jacklib.jack_midi_clear_buffer(port_buffer) + +def midi_max_event_size(port_buffer): + jacklib.jack_midi_max_event_size.argtypes = [c_void_p] + jacklib.jack_midi_max_event_size.restype = c_size_t + return jacklib.jack_midi_max_event_size(port_buffer) + +def midi_event_reserve(port_buffer, time, data_size): + jacklib.jack_midi_event_reserve.argtypes = [c_void_p, jack_nframes_t, c_size_t] + jacklib.jack_midi_event_reserve.restype = POINTER(jack_midi_data_t) + return jacklib.jack_midi_event_reserve(port_buffer, time, data_size) + +def midi_event_write(port_buffer, time, data, data_size): + jacklib.jack_midi_event_write.argtypes = [c_void_p, jack_nframes_t, POINTER(jack_midi_data_t), c_size_t] + jacklib.jack_midi_event_write.restype = c_int + return jacklib.jack_midi_event_write(port_buffer, time, data, data_size) + +def midi_get_lost_event_count(port_buffer): + jacklib.jack_midi_get_lost_event_count.argtypes = [c_void_p] + jacklib.jack_midi_get_lost_event_count.restype = c_uint32 + return jacklib.jack_midi_get_lost_event_count(port_buffer) + + +# Session + + +def set_timebase_callback(client, session_callback, arg): + jacklib.jack_set_timebase_callback.argtypes = [POINTER(jack_client_t), JackSessionCallback, c_void_p] + jacklib.jack_set_timebase_callback.restype = c_int + return jacklib.jack_set_timebase_callback(client, conditional, JackSessionCallback(session_callback), arg) + +def session_reply(client, event): + jacklib.jack_session_reply.argtypes = [POINTER(jack_client_t), POINTER(jack_session_event_t)] + jacklib.jack_session_reply.restype = c_int + return jacklib.jack_session_reply(client, event) + +def session_event_free(client, event): + jacklib.jack_session_event_free.argtypes = [POINTER(jack_client_t), POINTER(jack_session_event_t)] + jacklib.jack_session_event_free.restype = c_int + return jacklib.jack_session_event_free(client, event) + +def client_get_uuid(client): + jacklib.jack_client_get_uuid.argtypes = [POINTER(jack_client_t)] + jacklib.jack_client_get_uuid.restype = c_char_p + return jacklib.jack_client_get_uuid(client) + +def session_notify(client, target, type_, path): + jacklib.jack_session_notify.argtypes = [POINTER(jack_client_t), c_char_p, jack_session_event_type_t, c_char_p] + jacklib.jack_session_notify.restype = POINTER(jack_session_command_t) + return jacklib.jack_session_notify(client, target.encode(), type_, path.encode()) + +def session_commands_free(cmds): + jacklib.jack_session_commands_free.argtypes = [POINTER(jack_session_command_t)] + jacklib.jack_session_commands_free.restype = None + return jacklib.jack_session_commands_free(cmds) + +def get_uuid_for_client_name(client, client_name): + jacklib.jack_get_uuid_for_client_name.argtypes = [POINTER(jack_client_t), c_char_p] + jacklib.jack_get_uuid_for_client_name.restype = c_char_p + return jacklib.jack_get_uuid_for_client_name(client, client_name.encode()) + +def get_client_name_by_uuid(client, client_uuid): + jacklib.jack_get_client_name_by_uuid.argtypes = [POINTER(jack_client_t), c_char_p] + jacklib.jack_get_client_name_by_uuid.restype = c_char_p + return jacklib.jack_get_client_name_by_uuid(client, client_uuid.encode()) + +def reserve_client_name(client, name, uuid): + jacklib.jack_reserve_client_name.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p] + jacklib.jack_reserve_client_name.restype = c_int + return jacklib.jack_reserve_client_name(client, name.encode(), uuid.encode()) + +def client_has_session_callback(client, client_name): + jacklib.jack_client_has_session_callback.argtypes = [POINTER(jack_client_t), c_char_p] + jacklib.jack_client_has_session_callback.restype = c_int + return jacklib.jack_client_has_session_callback(client, client_name.encode())