#define __STDC_FORMAT_MACROS 1

#include <inttypes.h>

#include "JackClient.h"

#include "JackError.h"

#include "JackGraphManager.h"

#include "JackEngineControl.h"

#include "JackClientControl.h"

#include "JackGlobals.h"

#include "JackTime.h"

#include "JackPortType.h"

#include "JackMetadata.h"

#include <math.h>

using namespace Jack;

#ifdef __cplusplus

extern "C"

{

#endif

typedef void (*print_function)(const char*);

typedef void *(*thread_routine)(void*);

LIB_EXPORT

void

jack_get_version(

int *major_ptr,

int *minor_ptr,

int *micro_ptr,

int *proto_ptr);

LIB_EXPORT

const char*

jack_get_version_string();

jack_client_t * jack_client_new_aux(const char* client_name,

jack_options_t options,

jack_status_t *status);

LIB_EXPORT jack_client_t * jack_client_open(const char* client_name,

jack_options_t options,

jack_status_t *status, ...);

LIB_EXPORT jack_client_t * jack_client_new(const char* client_name);

LIB_EXPORT int jack_client_name_size(void);

LIB_EXPORT char* jack_get_client_name(jack_client_t *client);

LIB_EXPORT int jack_internal_client_new(const char* client_name,

const char* load_name,

const char* load_init);

LIB_EXPORT void jack_internal_client_close(const char* client_name);

LIB_EXPORT int jack_is_realtime(jack_client_t *client);

LIB_EXPORT void jack_on_shutdown(jack_client_t *client,

JackShutdownCallback shutdown_callback, void *arg);

LIB_EXPORT void jack_on_info_shutdown(jack_client_t *client,

JackInfoShutdownCallback shutdown_callback, void *arg);

LIB_EXPORT int jack_set_process_callback(jack_client_t *client,

JackProcessCallback process_callback,

void *arg);

LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t *client, int status);

// new

LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t*);

LIB_EXPORT void jack_cycle_signal(jack_client_t*, int status);

LIB_EXPORT int jack_set_process_thread(jack_client_t* client, JackThreadCallback fun, void *arg);

LIB_EXPORT int jack_set_thread_init_callback(jack_client_t *client,

JackThreadInitCallback thread_init_callback,

void *arg);

LIB_EXPORT int jack_set_freewheel_callback(jack_client_t *client,

JackFreewheelCallback freewheel_callback,

void *arg);

LIB_EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);

LIB_EXPORT int jack_set_buffer_size(jack_client_t *client, jack_nframes_t nframes);

LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t *client,

JackBufferSizeCallback bufsize_callback,

void *arg);

LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t *client,

JackSampleRateCallback srate_callback,

void *arg);

LIB_EXPORT int jack_set_client_registration_callback(jack_client_t *,

JackClientRegistrationCallback

registration_callback, void *arg);

LIB_EXPORT int jack_set_port_registration_callback(jack_client_t *,

JackPortRegistrationCallback

registration_callback, void *arg);

LIB_EXPORT int jack_set_port_connect_callback(jack_client_t *,

JackPortConnectCallback

connect_callback, void *arg);

LIB_EXPORT int jack_set_port_rename_callback(jack_client_t *,

JackPortRenameCallback

rename_callback, void *arg);

LIB_EXPORT int jack_set_graph_order_callback(jack_client_t *,

JackGraphOrderCallback graph_callback,

void *);

LIB_EXPORT int jack_set_xrun_callback(jack_client_t *,

JackXRunCallback xrun_callback, void *arg);

LIB_EXPORT int jack_set_latency_callback(jack_client_t *client,

JackLatencyCallback latency_callback, void *arg);

LIB_EXPORT int jack_activate(jack_client_t *client);

LIB_EXPORT int jack_deactivate(jack_client_t *client);

LIB_EXPORT jack_port_t * jack_port_register(jack_client_t *client,

const char* port_name,

const char* port_type,

unsigned long flags,

unsigned long buffer_size);

LIB_EXPORT int jack_port_unregister(jack_client_t *, jack_port_t *);

LIB_EXPORT void * jack_port_get_buffer(jack_port_t *, jack_nframes_t);

LIB_EXPORT jack_uuid_t jack_port_uuid(const jack_port_t*);

LIB_EXPORT const char* jack_port_name(const jack_port_t *port);

LIB_EXPORT const char* jack_port_short_name(const jack_port_t *port);

LIB_EXPORT int jack_port_flags(const jack_port_t *port);

LIB_EXPORT const char* jack_port_type(const jack_port_t *port);

LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port);

LIB_EXPORT int jack_port_is_mine(const jack_client_t *, const jack_port_t *port);

LIB_EXPORT int jack_port_connected(const jack_port_t *port);

LIB_EXPORT int jack_port_connected_to(const jack_port_t *port,

const char* port_name);

LIB_EXPORT const char* * jack_port_get_connections(const jack_port_t *port);

LIB_EXPORT const char* * jack_port_get_all_connections(const jack_client_t *client,

const jack_port_t *port);

LIB_EXPORT int jack_port_tie(jack_port_t *src, jack_port_t *dst);

LIB_EXPORT int jack_port_untie(jack_port_t *port);

// Old latency API

LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t *port);

LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t *,

jack_port_t *port);

LIB_EXPORT void jack_port_set_latency(jack_port_t *, jack_nframes_t);

LIB_EXPORT int jack_recompute_total_latency(jack_client_t*, jack_port_t* port);

// New latency API

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

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

LIB_EXPORT int jack_recompute_total_latencies(jack_client_t*);

LIB_EXPORT int jack_port_set_name(jack_port_t *port, const char* port_name);

LIB_EXPORT int jack_port_rename(jack_client_t *client, jack_port_t *port, const char* port_name);

LIB_EXPORT int jack_port_set_alias(jack_port_t *port, const char* alias);

LIB_EXPORT int jack_port_unset_alias(jack_port_t *port, const char* alias);

LIB_EXPORT int jack_port_get_aliases(const jack_port_t *port, char* const aliases[2]);

LIB_EXPORT int jack_port_request_monitor(jack_port_t *port, int onoff);

LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t *client,

const char* port_name, int onoff);

LIB_EXPORT int jack_port_ensure_monitor(jack_port_t *port, int onoff);

LIB_EXPORT int jack_port_monitoring_input(jack_port_t *port);

LIB_EXPORT int jack_connect(jack_client_t *,

const char* source_port,

const char* destination_port);

LIB_EXPORT int jack_disconnect(jack_client_t *,

const char* source_port,

const char* destination_port);

LIB_EXPORT int jack_port_disconnect(jack_client_t *, jack_port_t *);

LIB_EXPORT int jack_port_name_size(void);

LIB_EXPORT int jack_port_type_size(void);

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

LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t *);

LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t *);

LIB_EXPORT const char* * jack_get_ports(jack_client_t *,

const char* port_name_pattern,

const char* type_name_pattern,

unsigned long flags);

LIB_EXPORT jack_port_t * jack_port_by_name(jack_client_t *, const char* port_name);

LIB_EXPORT jack_port_t * jack_port_by_id(jack_client_t *client,

jack_port_id_t port_id);

LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t *);

LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t *);

LIB_EXPORT jack_time_t jack_get_time();

LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t usecs);

LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames);

LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t *);

LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t *client);

LIB_EXPORT int jack_get_cycle_times(const jack_client_t *client,

jack_nframes_t *current_frames,

jack_time_t *current_usecs,

jack_time_t *next_usecs,

float *period_usecs);

LIB_EXPORT float jack_cpu_load(jack_client_t *client);

LIB_EXPORT float jack_max_cpu_load(jack_client_t *client);

LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t *);

LIB_EXPORT void jack_set_error_function(print_function);

LIB_EXPORT void jack_set_info_function(print_function);

LIB_EXPORT float jack_get_max_delayed_usecs(jack_client_t *client);

LIB_EXPORT float jack_get_xrun_delayed_usecs(jack_client_t *client);

LIB_EXPORT void jack_reset_max_delayed_usecs(jack_client_t *client);

LIB_EXPORT int jack_release_timebase(jack_client_t *client);

LIB_EXPORT int jack_set_sync_callback(jack_client_t *client,

JackSyncCallback sync_callback,

void *arg);

LIB_EXPORT int jack_set_sync_timeout(jack_client_t *client,

jack_time_t timeout);

LIB_EXPORT int jack_set_timebase_callback(jack_client_t *client,

int conditional,

JackTimebaseCallback timebase_callback,

void *arg);

LIB_EXPORT int jack_transport_locate(jack_client_t *client,

jack_nframes_t frame);

LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t *client,

jack_position_t *pos);

LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t *client);

LIB_EXPORT int jack_transport_reposition(jack_client_t *client,

const jack_position_t *pos);

LIB_EXPORT void jack_transport_start(jack_client_t *client);

LIB_EXPORT void jack_transport_stop(jack_client_t *client);

LIB_EXPORT void jack_get_transport_info(jack_client_t *client,

jack_transport_info_t *tinfo);

LIB_EXPORT void jack_set_transport_info(jack_client_t *client,

jack_transport_info_t *tinfo);

LIB_EXPORT int jack_client_real_time_priority(jack_client_t*);

LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t*);

LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority);

LIB_EXPORT int jack_client_create_thread(jack_client_t* client,

jack_native_thread_t *thread,

int priority,

int realtime, // boolean

thread_routine routine,

void *arg);

LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread);

LIB_EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread);

LIB_EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread);

#ifndef WIN32

LIB_EXPORT void jack_set_thread_creator(jack_thread_creator_t jtc);

#endif

LIB_EXPORT char * jack_get_internal_client_name(jack_client_t *client,

jack_intclient_t intclient);

LIB_EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t *client,

const char* client_name,

jack_status_t *status);

LIB_EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client,

const char* client_name,

jack_options_t options,

jack_status_t *status, ...);

LIB_EXPORT jack_status_t jack_internal_client_unload(jack_client_t *client,

jack_intclient_t intclient);

LIB_EXPORT void jack_free(void* ptr);

LIB_EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg);

LIB_EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char* path);

LIB_EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event);

LIB_EXPORT void jack_session_event_free(jack_session_event_t* ev);

LIB_EXPORT char* jack_client_get_uuid (jack_client_t *client);

LIB_EXPORT char* jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name);

LIB_EXPORT char* jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid);

LIB_EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* name, const char* uuid);

LIB_EXPORT void jack_session_commands_free(jack_session_command_t *cmds);

LIB_EXPORT int jack_client_has_session_callback(jack_client_t *client, const char* client_name);

LIB_EXPORT jack_uuid_t jack_client_uuid_generate();

LIB_EXPORT jack_uuid_t jack_port_uuid_generate(uint32_t port_id);

LIB_EXPORT uint32_t jack_uuid_to_index(jack_uuid_t);

LIB_EXPORT int jack_uuid_compare(jack_uuid_t, jack_uuid_t);

LIB_EXPORT void jack_uuid_copy(jack_uuid_t* dst, jack_uuid_t src);

LIB_EXPORT void jack_uuid_clear(jack_uuid_t*);

LIB_EXPORT int jack_uuid_parse(const char* buf, jack_uuid_t*);

LIB_EXPORT void jack_uuid_unparse(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);

LIB_EXPORT int jack_uuid_empty(jack_uuid_t);

LIB_EXPORT int jack_set_property(jack_client_t*, jack_uuid_t subject, const char* key, const char* value, const char* type);

LIB_EXPORT int jack_get_property(jack_uuid_t subject, const char* key, char** value, char** type);

LIB_EXPORT void jack_free_description(jack_description_t* desc, int free_description_itself);

LIB_EXPORT int jack_get_properties(jack_uuid_t subject, jack_description_t* desc);

LIB_EXPORT int jack_get_all_properties(jack_description_t** descs);

LIB_EXPORT int jack_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key);

LIB_EXPORT int jack_remove_properties(jack_client_t* client, jack_uuid_t subject);

LIB_EXPORT int jack_remove_all_properties(jack_client_t* client);

LIB_EXPORT int jack_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg);

#ifdef __cplusplus

}

#endif

static inline bool CheckPort(jack_port_id_t port_index)

{

return (port_index > 0 && port_index < PORT_NUM_MAX);

}

static inline bool CheckBufferSize(jack_nframes_t buffer_size)

{

return (buffer_size >= 1 && buffer_size <= BUFFER_SIZE_MAX);

}

static inline void WaitGraphChange()

}

LIB_EXPORT void jack_set_error_function(print_function func)

{

jack_error_callback = (func == NULL) ? &default_jack_error_callback : func;

}

LIB_EXPORT void jack_set_info_function(print_function func)

{

jack_info_callback = (func == NULL) ? &default_jack_info_callback : func;

}

LIB_EXPORT jack_client_t* jack_client_new(const char* client_name)

{

JackGlobals::CheckContext("jack_client_new");

try {

assert(JackGlobals::fOpenMutex);

JackGlobals::fOpenMutex->Lock();

jack_error("jack_client_new: deprecated");

int options = JackUseExactName;

if (getenv("JACK_START_SERVER") == NULL) {

options |= JackNoStartServer;

}

jack_client_t* res = jack_client_new_aux(client_name, (jack_options_t)options, NULL);

JackGlobals::fOpenMutex->Unlock();

return res;

} catch (std::bad_alloc& e) {

jack_error("Memory allocation error...");

return NULL;

} catch (...) {

jack_error("Unknown error...");

return NULL;

}

}

LIB_EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)

{

JackGlobals::CheckContext("jack_port_get_buffer");

uintptr_t port_aux = (uintptr_t)port;

jack_port_id_t myport = (jack_port_id_t)port_aux;

if (!CheckPort(myport)) {

jack_error("jack_port_get_buffer called with an incorrect port %ld", myport);

return NULL;

} else {

JackGraphManager* manager = GetGraphManager();

return (manager ? manager->GetBuffer(myport, frames) : NULL);

}

}

LIB_EXPORT jack_uuid_t jack_port_uuid(const jack_port_t* port)

}

LIB_EXPORT const char* jack_port_name(const jack_port_t* port)

{

JackGlobals::CheckContext("jack_port_name");

uintptr_t port_aux = (uintptr_t)port;

jack_port_id_t myport = (jack_port_id_t)port_aux;

if (!CheckPort(myport)) {

jack_error("jack_port_name called with an incorrect port %ld", myport);

return NULL;

} else {

JackGraphManager* manager = GetGraphManager();

return (manager ? manager->GetPort(myport)->GetName() : NULL);

}

}

LIB_EXPORT const char* jack_port_short_name(const jack_port_t* port)

{

JackGlobals::CheckContext("jack_port_short_name");

uintptr_t port_aux = (uintptr_t)port;

jack_port_id_t myport = (jack_port_id_t)port_aux;

if (!CheckPort(myport)) {

jack_error("jack_port_short_name called with an incorrect port %ld", myport);

return NULL;

} else {

JackGraphManager* manager = GetGraphManager();

return (manager ? manager->GetPort(myport)->GetShortName() : NULL);

}

}

LIB_EXPORT int jack_port_flags(const jack_port_t* port)

}

LIB_EXPORT const char* jack_port_type(const jack_port_t* port)

{

JackGlobals::CheckContext("jack_port_type");

uintptr_t port_aux = (uintptr_t)port;

jack_port_id_t myport = (jack_port_id_t)port_aux;

if (!CheckPort(myport)) {

jack_error("jack_port_flags called an incorrect port %ld", myport);

return NULL;

} else {

JackGraphManager* manager = GetGraphManager();

return (manager ? manager->GetPort(myport)->GetType() : NULL);

}

}

LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port)

}

LIB_EXPORT int jack_port_connected(const jack_port_t* port)

}

LIB_EXPORT int jack_port_connected_to(const jack_port_t* port, const char* port_name)

}

LIB_EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)

}

LIB_EXPORT int jack_port_untie(jack_port_t* port)

}

LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)

}

LIB_EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)

}

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

}

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

}

LIB_EXPORT int jack_recompute_total_latency(jack_client_t* ext_client, jack_port_t* port)

}

LIB_EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)

}

LIB_EXPORT int jack_port_set_name(jack_port_t* port, const char* name)

}

LIB_EXPORT int jack_port_rename(jack_client_t* ext_client, jack_port_t* port, const char* name)

}

LIB_EXPORT int jack_port_set_alias(jack_port_t* port, const char* name)

}

LIB_EXPORT int jack_port_unset_alias(jack_port_t* port, const char* name)

}

LIB_EXPORT int jack_port_get_aliases(const jack_port_t* port, char* const aliases[2])

}

LIB_EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)

}

LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)

}

LIB_EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)

}

LIB_EXPORT int jack_port_monitoring_input(jack_port_t* port)

}

LIB_EXPORT int jack_is_realtime(jack_client_t* ext_client)

}

LIB_EXPORT void jack_on_shutdown(jack_client_t* ext_client, JackShutdownCallback callback, void* arg)

}

LIB_EXPORT void jack_on_info_shutdown(jack_client_t* ext_client, JackInfoShutdownCallback callback, void* arg)

}

LIB_EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)

}

LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t* ext_client, int status)

}

LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t* ext_client)

}

LIB_EXPORT void jack_cycle_signal(jack_client_t* ext_client, int status)

}

LIB_EXPORT int jack_set_process_thread(jack_client_t* ext_client, JackThreadCallback fun, void *arg)

}

LIB_EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)

}

LIB_EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)

}

LIB_EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer_size)

}

LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)

}

LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg)

}

LIB_EXPORT int jack_set_client_registration_callback(jack_client_t* ext_client, JackClientRegistrationCallback registration_callback, void* arg)

}

LIB_EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)

}

LIB_EXPORT int jack_set_port_connect_callback(jack_client_t* ext_client, JackPortConnectCallback portconnect_callback, void* arg)