00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "jack.h"
00021 #include "JackExports.h"
00022 #include <dlfcn.h>
00023 #include <stdarg.h>
00024 #include <stdio.h>
00025 #include <dirent.h>
00026 #include <string.h>
00027
00028 #ifdef __cplusplus
00029 extern "C"
00030 {
00031 #endif
00032
00033 EXPORT int jack_client_name_size (void);
00034 EXPORT char* jack_get_client_name (jack_client_t *client);
00035 EXPORT int jack_internal_client_new (const char *client_name,
00036 const char *load_name,
00037 const char *load_init);
00038 EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name);
00039 EXPORT void jack_internal_client_close (const char *client_name);
00040 EXPORT void my_jack_internal_client_close (jack_client_t* client);
00041 EXPORT int jack_is_realtime (jack_client_t *client);
00042 EXPORT void jack_on_shutdown (jack_client_t *client,
00043 void (*function)(void *arg), void *arg);
00044 EXPORT int jack_set_process_callback (jack_client_t *client,
00045 JackProcessCallback process_callback,
00046 void *arg);
00047 EXPORT int jack_set_thread_init_callback (jack_client_t *client,
00048 JackThreadInitCallback thread_init_callback,
00049 void *arg);
00050 EXPORT int jack_set_freewheel_callback (jack_client_t *client,
00051 JackFreewheelCallback freewheel_callback,
00052 void *arg);
00053 EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);
00054 EXPORT int jack_set_buffer_size (jack_client_t *client, jack_nframes_t nframes);
00055 EXPORT int jack_set_buffer_size_callback (jack_client_t *client,
00056 JackBufferSizeCallback bufsize_callback,
00057 void *arg);
00058 EXPORT int jack_set_sample_rate_callback (jack_client_t *client,
00059 JackSampleRateCallback srate_callback,
00060 void *arg);
00061 EXPORT int jack_set_port_registration_callback (jack_client_t *,
00062 JackPortRegistrationCallback
00063 registration_callback, void *arg);
00064 EXPORT int jack_set_graph_order_callback (jack_client_t *,
00065 JackGraphOrderCallback graph_callback,
00066 void *);
00067 EXPORT int jack_set_xrun_callback (jack_client_t *,
00068 JackXRunCallback xrun_callback, void *arg);
00069 EXPORT int jack_activate (jack_client_t *client);
00070 EXPORT int jack_deactivate (jack_client_t *client);
00071 EXPORT jack_port_t * jack_port_register (jack_client_t *client,
00072 const char *port_name,
00073 const char *port_type,
00074 unsigned long flags,
00075 unsigned long buffer_size);
00076 EXPORT int jack_port_unregister (jack_client_t *, jack_port_t *);
00077 EXPORT void * jack_port_get_buffer (jack_port_t *, jack_nframes_t);
00078 EXPORT const char * jack_port_name (const jack_port_t *port);
00079 EXPORT const char * jack_port_short_name (const jack_port_t *port);
00080 EXPORT int jack_port_flags (const jack_port_t *port);
00081 EXPORT const char * jack_port_type (const jack_port_t *port);
00082 EXPORT int jack_port_is_mine (const jack_client_t *, const jack_port_t *port);
00083 EXPORT int jack_port_connected (const jack_port_t *port);
00084 EXPORT int jack_port_connected_to (const jack_port_t *port,
00085 const char *port_name);
00086 EXPORT const char ** jack_port_get_connections (const jack_port_t *port);
00087 EXPORT const char ** jack_port_get_all_connections (const jack_client_t *client,
00088 const jack_port_t *port);
00089 EXPORT int jack_port_tie (jack_port_t *src, jack_port_t *dst);
00090 EXPORT int jack_port_untie (jack_port_t *port);
00091 EXPORT int jack_port_lock (jack_client_t *, jack_port_t *);
00092 EXPORT int jack_port_unlock (jack_client_t *, jack_port_t *);
00093 EXPORT jack_nframes_t jack_port_get_latency (jack_port_t *port);
00094 EXPORT jack_nframes_t jack_port_get_total_latency (jack_client_t *,
00095 jack_port_t *port);
00096 EXPORT void jack_port_set_latency (jack_port_t *, jack_nframes_t);
00097 EXPORT int jack_recompute_total_latencies (jack_client_t*);
00098 EXPORT int jack_port_set_name (jack_port_t *port, const char *port_name);
00099 EXPORT int jack_port_request_monitor (jack_port_t *port, int onoff);
00100 EXPORT int jack_port_request_monitor_by_name (jack_client_t *client,
00101 const char *port_name, int onoff);
00102 EXPORT int jack_port_ensure_monitor (jack_port_t *port, int onoff);
00103 EXPORT int jack_port_monitoring_input (jack_port_t *port);
00104 EXPORT int jack_connect (jack_client_t *,
00105 const char *source_port,
00106 const char *destination_port);
00107 EXPORT int jack_disconnect (jack_client_t *,
00108 const char *source_port,
00109 const char *destination_port);
00110 EXPORT int jack_port_disconnect (jack_client_t *, jack_port_t *);
00111 EXPORT int jack_port_name_size(void);
00112 EXPORT int jack_port_type_size(void);
00113 EXPORT jack_nframes_t jack_get_sample_rate (jack_client_t *);
00114 EXPORT jack_nframes_t jack_get_buffer_size (jack_client_t *);
00115 EXPORT const char ** jack_get_ports (jack_client_t *,
00116 const char *port_name_pattern,
00117 const char *type_name_pattern,
00118 unsigned long flags);
00119 EXPORT jack_port_t * jack_port_by_name (jack_client_t *, const char *port_name);
00120 EXPORT jack_port_t * jack_port_by_id (jack_client_t *client,
00121 jack_port_id_t port_id);
00122 EXPORT int jack_engine_takeover_timebase (jack_client_t *);
00123 EXPORT jack_nframes_t jack_frames_since_cycle_start (const jack_client_t *);
00124 EXPORT jack_nframes_t jack_frame_time (const jack_client_t *);
00125 EXPORT jack_nframes_t jack_last_frame_time (const jack_client_t *client);
00126 EXPORT float jack_cpu_load (jack_client_t *client);
00127 EXPORT pthread_t jack_client_thread_id (jack_client_t *);
00128 EXPORT void jack_set_error_function (void (*func)(const char *));
00129
00130 EXPORT float jack_get_max_delayed_usecs (jack_client_t *client);
00131 EXPORT float jack_get_xrun_delayed_usecs (jack_client_t *client);
00132 EXPORT void jack_reset_max_delayed_usecs (jack_client_t *client);
00133
00134 EXPORT int jack_release_timebase (jack_client_t *client);
00135 EXPORT int jack_set_sync_callback (jack_client_t *client,
00136 JackSyncCallback sync_callback,
00137 void *arg);
00138 EXPORT int jack_set_sync_timeout (jack_client_t *client,
00139 jack_time_t timeout);
00140 EXPORT int jack_set_timebase_callback (jack_client_t *client,
00141 int conditional,
00142 JackTimebaseCallback timebase_callback,
00143 void *arg);
00144 EXPORT int jack_transport_locate (jack_client_t *client,
00145 jack_nframes_t frame);
00146 EXPORT jack_transport_state_t jack_transport_query (const jack_client_t *client,
00147 jack_position_t *pos);
00148 EXPORT jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client);
00149 EXPORT int jack_transport_reposition (jack_client_t *client,
00150 jack_position_t *pos);
00151 EXPORT void jack_transport_start (jack_client_t *client);
00152 EXPORT void jack_transport_stop (jack_client_t *client);
00153 EXPORT void jack_get_transport_info (jack_client_t *client,
00154 jack_transport_info_t *tinfo);
00155 EXPORT void jack_set_transport_info (jack_client_t *client,
00156 jack_transport_info_t *tinfo);
00157
00158 EXPORT int jack_acquire_real_time_scheduling (pthread_t thread, int priority);
00159 EXPORT int jack_client_create_thread (jack_client_t* client,
00160 pthread_t *thread,
00161 int priority,
00162 int realtime,
00163 void *(*start_routine)(void*),
00164 void *arg);
00165 EXPORT int jack_drop_real_time_scheduling (pthread_t thread);
00166
00167 EXPORT char * jack_get_internal_client_name (jack_client_t *client,
00168 jack_intclient_t intclient);
00169 EXPORT jack_intclient_t jack_internal_client_handle (jack_client_t *client,
00170 const char *client_name,
00171 jack_status_t *status);
00172 EXPORT jack_intclient_t jack_internal_client_load (jack_client_t *client,
00173 const char *client_name,
00174 jack_options_t options,
00175 jack_status_t *status, ...);
00176 EXPORT jack_status_t jack_internal_client_unload (jack_client_t *client,
00177 jack_intclient_t intclient);
00178
00179 EXPORT jack_client_t * jack_client_open (const char *client_name,
00180 jack_options_t options,
00181 jack_status_t *status, ...);
00182 EXPORT jack_client_t * jack_client_new (const char *client_name);
00183 EXPORT int jack_client_close (jack_client_t *client);
00184
00185 #ifdef __cplusplus
00186 }
00187 #endif
00188
00189
00190
00191 typedef void* (*jack_port_get_buffer_fun_def)(jack_port_t* port, jack_nframes_t frames);
00192 static jack_port_get_buffer_fun_def jack_port_get_buffer_fun = 0;
00193 EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)
00194 {
00195 return (*jack_port_get_buffer_fun)(port, frames);
00196 }
00197
00198 typedef const char* (*jack_port_name_fun_def)(const jack_port_t* port);
00199 static jack_port_name_fun_def jack_port_name_fun = 0;
00200 EXPORT const char* jack_port_name(const jack_port_t* port)
00201 {
00202 return (*jack_port_name_fun)(port);
00203 }
00204
00205 typedef const char* (*jack_port_short_name_fun_def) (const jack_port_t* port);
00206 static jack_port_short_name_fun_def jack_port_short_name_fun = 0;
00207 EXPORT const char* jack_port_short_name(const jack_port_t* port)
00208 {
00209 return (*jack_port_short_name_fun)(port);
00210 }
00211
00212 typedef int (*jack_port_flags_fun_def)(const jack_port_t* port);
00213 static jack_port_flags_fun_def jack_port_flags_fun = 0;
00214 EXPORT int jack_port_flags(const jack_port_t* port)
00215 {
00216 return (*jack_port_flags_fun)(port);
00217 }
00218
00219 typedef const char* (*jack_port_type_fun_def)(const jack_port_t* port);
00220 static jack_port_type_fun_def jack_port_type_fun = 0;
00221 EXPORT const char* jack_port_type(const jack_port_t* port)
00222 {
00223 return (*jack_port_type_fun)(port);
00224 }
00225
00226 typedef int (*jack_port_connected_fun_def)(const jack_port_t* port);
00227 static jack_port_connected_fun_def jack_port_connected_fun = 0;
00228 EXPORT int jack_port_connected(const jack_port_t* port)
00229 {
00230 return (*jack_port_connected_fun)(port);
00231 }
00232
00233 typedef int (*jack_port_connected_to_fun_def)(const jack_port_t* port, const char* portname);
00234 static jack_port_connected_to_fun_def jack_port_connected_to_fun = 0;
00235 EXPORT int jack_port_connected_to(const jack_port_t* port, const char* portname)
00236 {
00237 return (*jack_port_connected_to_fun)(port, portname);
00238 }
00239
00240 typedef int (*jack_port_tie_fun_def)(jack_port_t* src, jack_port_t* dst);
00241 static jack_port_tie_fun_def jack_port_tie_fun = 0;
00242 EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)
00243 {
00244 return (*jack_port_tie_fun)(src, dst);
00245 }
00246
00247 typedef int (*jack_port_untie_fun_def)(jack_port_t* port);
00248 static jack_port_untie_fun_def jack_port_untie_fun = 0;
00249 EXPORT int jack_port_untie(jack_port_t* port)
00250 {
00251 return (*jack_port_untie_fun)(port);
00252 }
00253
00254 typedef jack_nframes_t (*jack_port_get_latency_fun_def)(jack_port_t* port);
00255 static jack_port_get_latency_fun_def jack_port_get_latency_fun = 0;
00256 EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)
00257 {
00258 return (*jack_port_get_latency)(port);
00259 }
00260
00261 typedef void (*jack_port_set_latency_fun_def)(jack_port_t* port, jack_nframes_t frames);
00262 static jack_port_set_latency_fun_def jack_port_set_latency_fun = 0;
00263 EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
00264 {
00265 (*jack_port_set_latency_fun)(port, frames);
00266 }
00267
00268 typedef int (*jack_recompute_total_latencies_fun_def)(jack_client_t* ext_client);
00269 static jack_recompute_total_latencies_fun_def jack_recompute_total_latencies_fun = 0;
00270 EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)
00271 {
00272 return (*jack_recompute_total_latencies_fun)(ext_client);
00273 }
00274
00275 typedef int (*jack_port_set_name_fun_def)(jack_port_t* port, const char* name);
00276 static jack_port_set_name_fun_def jack_port_set_name_fun = 0;
00277 EXPORT int jack_port_set_name(jack_port_t* port, const char* name)
00278 {
00279 return (*jack_port_set_name_fun)(port, name);
00280 }
00281
00282 typedef int (*jack_port_request_monitor_fun_def)(jack_port_t* port, int onoff);
00283 static jack_port_request_monitor_fun_def jack_port_request_monitor_fun = 0;
00284 EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)
00285 {
00286 return (*jack_port_request_monitor_fun)(port, onoff);
00287 }
00288
00289 typedef int (*jack_port_request_monitor_by_name_fun_def)(jack_client_t* ext_client, const char* port_name, int onoff);
00290 static jack_port_request_monitor_by_name_fun_def jack_port_request_monitor_by_name_fun = 0;
00291 EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)
00292 {
00293 return (*jack_port_request_monitor_by_name_fun)(ext_client, port_name, onoff);
00294 }
00295
00296 typedef int (*jack_port_ensure_monitor_fun_def)(jack_port_t* port, int onoff);
00297 static jack_port_ensure_monitor_fun_def jack_port_ensure_monitor_fun = 0;
00298 EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)
00299 {
00300 return (*jack_port_ensure_monitor_fun)(port, onoff);
00301 }
00302
00303 typedef int (*jack_port_monitoring_input_fun_def)(jack_port_t* port);
00304 static jack_port_monitoring_input_fun_def jack_port_monitoring_input_fun = 0;
00305 EXPORT int jack_port_monitoring_input(jack_port_t* port)
00306 {
00307 return (*jack_port_monitoring_input_fun)(port);
00308 }
00309
00310 typedef int (*jack_is_realtime_fun_def)(jack_client_t* ext_client);
00311 static jack_is_realtime_fun_def jack_is_realtime_fun = 0;
00312 EXPORT int jack_is_realtime(jack_client_t* ext_client)
00313 {
00314 return (*jack_is_realtime_fun)(ext_client);
00315 }
00316
00317 typedef void (*shutdown_fun)(void* arg);
00318 typedef void (*jack_on_shutdown_fun_def)(jack_client_t* ext_client, shutdown_fun callback, void* arg);
00319 static jack_on_shutdown_fun_def jack_on_shutdown_fun = 0;
00320 EXPORT void jack_on_shutdown(jack_client_t* ext_client, shutdown_fun callback, void* arg)
00321 {
00322 return (*jack_on_shutdown_fun)(ext_client, callback, arg);
00323 }
00324
00325 typedef int (*jack_set_process_callback_fun_def)(jack_client_t* ext_client, JackProcessCallback callback, void* arg);
00326 static jack_set_process_callback_fun_def jack_set_process_callback_fun = 0;
00327 EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)
00328 {
00329 return (*jack_set_process_callback_fun)(ext_client, callback, arg);
00330 }
00331
00332 typedef int (*jack_set_freewheel_callback_fun_def)(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg);
00333 static jack_set_freewheel_callback_fun_def jack_set_freewheel_callback_fun = 0;
00334 EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)
00335 {
00336 return (*jack_set_freewheel_callback_fun)(ext_client, freewheel_callback, arg);
00337 }
00338
00339 typedef int (*jack_set_freewheel_fun_def)(jack_client_t* ext_client, int onoff);
00340 static jack_set_freewheel_fun_def jack_set_freewheel_fun = 0;
00341 EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)
00342 {
00343 return (*jack_set_freewheel_fun)(ext_client, onoff);
00344 }
00345
00346 typedef int (*jack_set_buffer_size_fun_def)(jack_client_t* ext_client, jack_nframes_t buffer_size);
00347 static jack_set_buffer_size_fun_def jack_set_buffer_size_fun = 0;
00348 EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer_size)
00349 {
00350 return (*jack_set_buffer_size_fun)(ext_client, buffer_size);
00351 }
00352
00353 typedef int (*jack_set_buffer_size_callback_fun_def)(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg);
00354 static jack_set_buffer_size_callback_fun_def jack_set_buffer_size_callback_fun = 0;
00355 EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)
00356 {
00357 return (*jack_set_buffer_size_callback_fun)(ext_client, bufsize_callback, arg);
00358 }
00359
00360 typedef int (*jack_set_sample_rate_callback_fun_def)(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg);
00361 static jack_set_sample_rate_callback_fun_def jack_set_sample_rate_callback_fun = 0;
00362 EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg)
00363 {
00364 return (*jack_set_sample_rate_callback_fun)(ext_client, srate_callback, arg);
00365 }
00366
00367 typedef int (*jack_set_port_registration_callback_fun_def)(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg);
00368 static jack_set_port_registration_callback_fun_def jack_set_port_registration_callback_fun = 0;
00369 EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)
00370 {
00371 return (*jack_set_port_registration_callback_fun)(ext_client, registration_callback, arg);
00372 }
00373
00374 typedef int (*jack_set_graph_order_callback_fun_def)(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg);
00375 static jack_set_graph_order_callback_fun_def jack_set_graph_order_callback_fun = 0;
00376 EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)
00377 {
00378 return (*jack_set_graph_order_callback_fun)(ext_client, graph_callback, arg);
00379 }
00380
00381 typedef int (*jack_set_xrun_callback_fun_def)(jack_client_t* ext_client, JackXRunCallback xrun_callback, void* arg);
00382 static jack_set_xrun_callback_fun_def jack_set_xrun_callback_fun = 0;
00383 EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xrun_callback, void* arg)
00384 {
00385 return (*jack_set_xrun_callback_fun)(ext_client, xrun_callback, arg);
00386 }
00387
00388 typedef int (*jack_set_thread_init_callback_fun_def)(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg);
00389 static jack_set_thread_init_callback_fun_def jack_set_thread_init_callback_fun = 0;
00390 EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg)
00391 {
00392 return (*jack_set_thread_init_callback_fun)(ext_client, init_callback, arg);
00393 }
00394
00395 typedef int (*jack_activate_fun_def)(jack_client_t* ext_client);
00396 static jack_activate_fun_def jack_activate_fun = 0;
00397 EXPORT int jack_activate(jack_client_t* ext_client)
00398 {
00399 return (*jack_activate_fun)(ext_client);
00400 }
00401
00402 typedef int (*jack_deactivate_fun_def)(jack_client_t* ext_client);
00403 static jack_deactivate_fun_def jack_deactivate_fun = 0;
00404 EXPORT int jack_deactivate(jack_client_t* ext_client)
00405 {
00406 return (*jack_deactivate_fun)(ext_client);
00407 }
00408
00409 typedef jack_port_t* (*jack_port_register_fun_def)(jack_client_t* ext_client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
00410 static jack_port_register_fun_def jack_port_register_fun = 0;
00411 EXPORT jack_port_t* jack_port_register(jack_client_t* ext_client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)
00412 {
00413 return (*jack_port_register_fun)(ext_client, port_name, port_type, flags, buffer_size);
00414 }
00415
00416 typedef int (*jack_port_unregister_fun_def)(jack_client_t* ext_client, jack_port_t* port);
00417 static jack_port_unregister_fun_def jack_port_unregister_fun = 0;
00418 EXPORT int jack_port_unregister(jack_client_t* ext_client, jack_port_t* port)
00419 {
00420 return (*jack_port_unregister_fun)(ext_client, port);
00421 }
00422
00423 typedef int (*jack_port_is_mine_fun_def)(const jack_client_t* ext_client, const jack_port_t* port);
00424 static jack_port_is_mine_fun_def jack_port_is_mine_fun = 0;
00425 EXPORT int jack_port_is_mine(const jack_client_t* ext_client, const jack_port_t* port)
00426 {
00427 return (*jack_port_is_mine_fun)(ext_client, port);
00428 }
00429
00430 typedef const char** (*jack_port_get_connections_fun_def)(const jack_port_t* port);
00431 static jack_port_get_connections_fun_def jack_port_get_connections_fun = 0;
00432 EXPORT const char** jack_port_get_connections(const jack_port_t* port)
00433 {
00434 return (*jack_port_get_connections_fun)(port);
00435 }
00436
00437
00438 typedef const char** (*jack_port_get_all_connections_fun_def)(const jack_client_t* ext_client, const jack_port_t* port);
00439 static jack_port_get_all_connections_fun_def jack_port_get_all_connections_fun = 0;
00440 EXPORT const char** jack_port_get_all_connections(const jack_client_t* ext_client, const jack_port_t* port)
00441 {
00442 return (*jack_port_get_all_connections_fun)(ext_client, port);
00443 }
00444
00445
00446 typedef int (*jack_port_lock_fun_def)(jack_client_t* ext_client, jack_port_t* port);
00447 static jack_port_lock_fun_def jack_port_lock_fun = 0;
00448 EXPORT int jack_port_lock(jack_client_t* ext_client, jack_port_t* port)
00449 {
00450 return (*jack_port_lock_fun)(ext_client, port);
00451 }
00452
00453
00454 typedef int (*jack_port_unlock_fun_def)(jack_client_t* ext_client, jack_port_t* port);
00455 static jack_port_unlock_fun_def jack_port_unlock_fun = 0;
00456 EXPORT int jack_port_ununlock(jack_client_t* ext_client, jack_port_t* port)
00457 {
00458 return (*jack_port_unlock_fun)(ext_client, port);
00459 }
00460
00461 typedef jack_nframes_t (*jack_port_get_total_latency_fun_def)(jack_client_t* ext_client, jack_port_t* port);
00462 static jack_port_get_total_latency_fun_def jack_port_get_total_latency_fun = 0;
00463 EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t* ext_client, jack_port_t* port)
00464 {
00465 return (*jack_port_get_total_latency_fun)(ext_client, port);
00466 }
00467
00468 typedef int (*jack_connect_fun_def)(jack_client_t* ext_client, const char* src, const char* dst);
00469 static jack_connect_fun_def jack_connect_fun = 0;
00470 EXPORT int jack_connect(jack_client_t* ext_client, const char* src, const char* dst)
00471 {
00472 return (*jack_connect_fun)(ext_client, src, dst);
00473 }
00474
00475 typedef int (*jack_disconnect_fun_def)(jack_client_t* ext_client, const char* src, const char* dst);
00476 static jack_disconnect_fun_def jack_disconnect_fun = 0;
00477 EXPORT int jack_disconnect(jack_client_t* ext_client, const char* src, const char* dst)
00478 {
00479 return (*jack_disconnect_fun)(ext_client, src, dst);
00480 }
00481
00482 typedef int (*jack_port_connect_fun_def)(jack_client_t* ext_client, jack_port_t* src, jack_port_t* dst);
00483 static jack_port_connect_fun_def jack_port_connect_fun = 0;
00484 EXPORT int jack_port_connect(jack_client_t* ext_client, jack_port_t* src, jack_port_t* dst)
00485 {
00486 return (*jack_port_connect_fun)(ext_client, src, dst);
00487 }
00488
00489 typedef int (*jack_port_disconnect_fun_def)(jack_client_t* ext_client, jack_port_t* src);
00490 static jack_port_disconnect_fun_def jack_port_disconnect_fun = 0;
00491 EXPORT int jack_port_disconnect(jack_client_t* ext_client, jack_port_t* src)
00492 {
00493 return (*jack_port_disconnect_fun)(ext_client, src);
00494 }
00495
00496 typedef jack_nframes_t (*jack_get_sample_rate_fun_def)(jack_client_t* ext_client);
00497 static jack_get_sample_rate_fun_def jack_get_sample_rate_fun = 0;
00498 EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t* ext_client)
00499 {
00500 return (*jack_get_sample_rate_fun)(ext_client);
00501 }
00502
00503 typedef jack_nframes_t (*jack_get_buffer_size_fun_def)(jack_client_t* ext_client);
00504 static jack_get_buffer_size_fun_def jack_get_buffer_size_fun = 0;
00505 EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t* ext_client)
00506 {
00507 return (*jack_get_buffer_size_fun)(ext_client);
00508 }
00509
00510 typedef const char** (*jack_get_ports_fun_def)(jack_client_t* ext_client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags);
00511 static jack_get_ports_fun_def jack_get_ports_fun = 0;
00512 EXPORT const char** jack_get_ports(jack_client_t* ext_client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)
00513 {
00514 return (*jack_get_ports_fun)(ext_client, port_name_pattern, type_name_pattern, flags);
00515 }
00516
00517 typedef jack_port_t* (*jack_port_by_name_fun_def)(jack_client_t* ext_client, const char* portname);
00518 static jack_port_by_name_fun_def jack_port_by_name_fun = 0;
00519 EXPORT jack_port_t* jack_port_by_name(jack_client_t* ext_client, const char* portname)
00520 {
00521 return (*jack_port_by_name_fun)(ext_client, portname);
00522 }
00523
00524 typedef jack_port_t* (*jack_port_by_id_fun_def)(const jack_client_t* ext_client, jack_port_id_t id);
00525 static jack_port_by_id_fun_def jack_port_by_id_fun = 0;
00526 EXPORT jack_port_t* jack_port_by_id(const jack_client_t* ext_client, jack_port_id_t id)
00527 {
00528 return (*jack_port_by_id_fun)(ext_client, id);
00529 }
00530
00531 typedef int (*jack_engine_takeover_timebase_fun_def)(jack_client_t* ext_client);
00532 static jack_engine_takeover_timebase_fun_def jack_engine_takeover_timebase_fun = 0;
00533 EXPORT int jack_engine_takeover_timebase(jack_client_t* ext_client)
00534 {
00535 return (*jack_engine_takeover_timebase_fun)(ext_client);
00536 }
00537
00538 typedef jack_nframes_t (*jack_frames_since_cycle_start_fun_def)(const jack_client_t* ext_client);
00539 static jack_frames_since_cycle_start_fun_def jack_frames_since_cycle_start_fun = 0;
00540 EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* ext_client)
00541 {
00542 return (*jack_frames_since_cycle_start_fun)(ext_client);
00543 }
00544
00545 typedef jack_nframes_t (*jack_frame_time_fun_def)(const jack_client_t* ext_client);
00546 static jack_frame_time_fun_def jack_frame_time_fun = 0;
00547 EXPORT jack_nframes_t jack_frame_time(const jack_client_t* ext_client)
00548 {
00549 return (*jack_frame_time_fun)(ext_client);
00550 }
00551
00552 typedef jack_nframes_t (*jack_last_frame_time_fun_def)(const jack_client_t* ext_client);
00553 static jack_last_frame_time_fun_def jack_last_frame_time_fun = 0;
00554 EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t* ext_client)
00555 {
00556 return (*jack_last_frame_time_fun)(ext_client);
00557 }
00558
00559 typedef float (*jack_cpu_load_fun_def)(jack_client_t* ext_client);
00560 static jack_cpu_load_fun_def jack_cpu_load_fun = 0;
00561 EXPORT float jack_cpu_load(jack_client_t* ext_client)
00562 {
00563 return (*jack_cpu_load_fun)(ext_client);
00564 }
00565
00566 typedef pthread_t (*jack_client_thread_id_fun_def)(jack_client_t* ext_client);
00567 static jack_client_thread_id_fun_def jack_client_thread_id_fun = 0;
00568 EXPORT pthread_t jack_client_thread_id(jack_client_t* ext_client)
00569 {
00570 return (*jack_client_thread_id_fun)(ext_client);
00571 }
00572
00573 typedef char* (*jack_get_client_name_fun_def)(jack_client_t* ext_client);
00574 static jack_get_client_name_fun_def jack_get_client_name_fun = 0;
00575 EXPORT char* jack_get_client_name (jack_client_t* ext_client)
00576 {
00577 return (*jack_get_client_name_fun)(ext_client);
00578 }
00579
00580 typedef int (*jack_client_name_size_fun_def)(void);
00581 static jack_client_name_size_fun_def jack_client_name_size_fun = 0;
00582 EXPORT int jack_client_name_size(void)
00583 {
00584 return (*jack_client_name_size_fun)();
00585 }
00586
00587 typedef int (*jack_port_name_size_fun_def)(void);
00588 static jack_port_name_size_fun_def jack_port_name_size_fun = 0;
00589 EXPORT int jack_port_name_size(void)
00590 {
00591 return (*jack_port_name_size_fun)();
00592 }
00593
00594
00595
00596 typedef int (*jack_release_timebase_fun_def)(jack_client_t* ext_client);
00597 static jack_release_timebase_fun_def jack_release_timebase_fun = 0;
00598 EXPORT int jack_release_timebase(jack_client_t* ext_client)
00599 {
00600 return (*jack_release_timebase_fun)(ext_client);
00601 }
00602
00603 typedef int (*jack_set_sync_callback_fun_def)(jack_client_t* ext_client, JackSyncCallback sync_callback, void *arg);
00604 static jack_set_sync_callback_fun_def jack_set_sync_callback_fun = 0;
00605 EXPORT int jack_set_sync_callback(jack_client_t* ext_client, JackSyncCallback sync_callback, void *arg)
00606 {
00607 return (*jack_set_sync_callback_fun)(ext_client, sync_callback, arg);
00608 }
00609
00610 typedef int (*jack_set_sync_timeout_fun_def)(jack_client_t* ext_client, jack_time_t timeout);
00611 static jack_set_sync_timeout_fun_def jack_set_sync_timeout_fun = 0;
00612 EXPORT int jack_set_sync_timeout(jack_client_t* ext_client, jack_time_t timeout)
00613 {
00614 return (*jack_set_sync_timeout_fun)(ext_client, timeout);
00615 }
00616
00617 typedef int (*jack_set_timebase_callback_fun_def)(jack_client_t* ext_client, int conditional, JackTimebaseCallback timebase_callback, void* arg);
00618 static jack_set_timebase_callback_fun_def jack_set_timebase_callback_fun = 0;
00619 EXPORT int jack_set_timebase_callback(jack_client_t* ext_client, int conditional, JackTimebaseCallback timebase_callback, void* arg)
00620 {
00621 return (*jack_set_timebase_callback_fun)(ext_client, conditional, timebase_callback, arg);
00622 }
00623
00624 typedef int (*jack_transport_locate_fun_def)(jack_client_t* ext_client, jack_nframes_t frame);
00625 static jack_transport_locate_fun_def jack_transport_locate_fun = 0;
00626 EXPORT int jack_transport_locate(jack_client_t* ext_client, jack_nframes_t frame)
00627 {
00628 return (*jack_transport_locate_fun)(ext_client, frame);
00629 }
00630
00631 typedef jack_transport_state_t (*jack_transport_query_fun_def)(const jack_client_t* ext_client, jack_position_t* pos);
00632 static jack_transport_query_fun_def jack_transport_query_fun = 0;
00633 EXPORT jack_transport_state_t jack_transport_query(const jack_client_t* ext_client, jack_position_t* pos)
00634 {
00635 return (*jack_transport_query_fun)(ext_client, pos);
00636 }
00637
00638 typedef jack_nframes_t (*jack_get_current_transport_frame_fun_def)(const jack_client_t* ext_client);
00639 static jack_get_current_transport_frame_fun_def jack_get_current_transport_frame_fun = 0;
00640 EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t* ext_client)
00641 {
00642 return (*jack_get_current_transport_frame_fun)(ext_client);
00643 }
00644
00645 typedef int (*jack_transport_reposition_fun_def)(jack_client_t* ext_client, jack_position_t* pos);
00646 static jack_transport_reposition_fun_def jack_transport_reposition_fun = 0;
00647 EXPORT int jack_transport_reposition(jack_client_t* ext_client, jack_position_t* pos)
00648 {
00649 return (*jack_transport_reposition_fun)(ext_client, pos);
00650 }
00651
00652 typedef void (*jack_transport_start_fun_def)(jack_client_t* ext_client);
00653 static jack_transport_start_fun_def jack_transport_start_fun = 0;
00654 EXPORT void jack_transport_start(jack_client_t* ext_client)
00655 {
00656 return (*jack_transport_start_fun)(ext_client);
00657 }
00658
00659 typedef void (*jack_transport_stop_fun_def)(jack_client_t* ext_client);
00660 static jack_transport_stop_fun_def jack_transport_stop_fun = 0;
00661 EXPORT void jack_transport_stop(jack_client_t* ext_client)
00662 {
00663 return (*jack_transport_stop_fun)(ext_client);
00664 }
00665
00666
00667
00668 typedef void (*jack_get_transport_info_fun_def)(jack_client_t* ext_client, jack_transport_info_t* tinfo);
00669 static jack_get_transport_info_fun_def jack_get_transport_info_fun = 0;
00670 EXPORT void jack_get_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)
00671 {
00672 (*jack_get_transport_info_fun)(ext_client, tinfo);
00673 }
00674
00675 typedef void (*jack_set_transport_info_fun_def)(jack_client_t* ext_client, jack_transport_info_t* tinfo);
00676 static jack_set_transport_info_fun_def jack_set_transport_info_fun = 0;
00677 EXPORT void jack_set_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)
00678 {
00679 (*jack_set_transport_info_fun)(ext_client, tinfo);
00680 }
00681
00682
00683
00684 typedef float (*jack_get_max_delayed_usecs_fun_def)(jack_client_t* ext_client);
00685 static jack_get_max_delayed_usecs_fun_def jack_get_max_delayed_usecs_fun = 0;
00686 EXPORT float jack_get_max_delayed_usecs(jack_client_t* ext_client)
00687 {
00688 return (*jack_get_max_delayed_usecs_fun)(ext_client);
00689 }
00690
00691 typedef float (*jack_get_xrun_delayed_usecs_fun_def)(jack_client_t* ext_client);
00692 static jack_get_xrun_delayed_usecs_fun_def jack_get_xrun_delayed_usecs_fun = 0;
00693 EXPORT float jack_get_xrun_delayed_usecs(jack_client_t* ext_client)
00694 {
00695 return (*jack_get_xrun_delayed_usecs_fun)(ext_client);
00696 }
00697
00698 typedef void (*jack_reset_max_delayed_usecs_fun_def)(jack_client_t* ext_client);
00699 static jack_reset_max_delayed_usecs_fun_def jack_reset_max_delayed_usecs_fun = 0;
00700 EXPORT void jack_reset_max_delayed_usecs(jack_client_t* ext_client)
00701 {
00702 (*jack_reset_max_delayed_usecs)(ext_client);
00703 }
00704
00705
00706
00707 typedef int (*jack_acquire_real_time_scheduling_fun_def)(pthread_t thread, int priority);
00708 static jack_acquire_real_time_scheduling_fun_def jack_acquire_real_time_scheduling_fun = 0;
00709 EXPORT int jack_acquire_real_time_scheduling(pthread_t thread, int priority)
00710 {
00711 return (*jack_acquire_real_time_scheduling_fun)(thread, priority);
00712 }
00713
00714 typedef void *(*start_routine)(void*);
00715 typedef int (*jack_client_create_thread_fun_def)(jack_client_t* client,
00716 pthread_t *thread,
00717 int priority,
00718 int realtime,
00719 start_routine callback,
00720 void *arg);
00721 static jack_client_create_thread_fun_def jack_client_create_thread_fun = 0;
00722 EXPORT int jack_client_create_thread(jack_client_t* client,
00723 pthread_t *thread,
00724 int priority,
00725 int realtime,
00726 start_routine callback,
00727 void *arg)
00728 {
00729 return (*jack_client_create_thread_fun)(client, thread, priority, realtime, callback, arg);
00730 }
00731
00732 typedef int (*jack_drop_real_time_scheduling_fun_def)(pthread_t thread);
00733 static jack_drop_real_time_scheduling_fun_def jack_drop_real_time_scheduling_fun = 0;
00734 EXPORT int jack_drop_real_time_scheduling(pthread_t thread)
00735 {
00736 return (*jack_drop_real_time_scheduling_fun)(thread);
00737 }
00738
00739
00740
00741 typedef char* (*jack_get_internal_client_name_fun_def)(jack_client_t* ext_client, jack_intclient_t intclient);
00742 static jack_get_internal_client_name_fun_def jack_get_internal_client_name_fun = 0;
00743 EXPORT char* jack_get_internal_client_name(jack_client_t* ext_client, jack_intclient_t intclient)
00744 {
00745 return (*jack_get_internal_client_name_fun)(ext_client, intclient);
00746 }
00747
00748 typedef jack_intclient_t (*jack_internal_client_handle_fun_def)(jack_client_t* ext_client, const char* client_name, jack_status_t* status);
00749 static jack_internal_client_handle_fun_def jack_internal_client_handle_fun = 0;
00750 EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t* ext_client, const char* client_name, jack_status_t* status)
00751 {
00752 return (*jack_internal_client_handle_fun)(ext_client, client_name, status);
00753 }
00754
00755 typedef jack_intclient_t (*jack_internal_client_load_fun_def)(jack_client_t* ext_client, const char* client_name, jack_options_t options, jack_status_t* status, ...);
00756 static jack_internal_client_load_fun_def jack_internal_client_load_fun = 0;
00757 EXPORT jack_intclient_t jack_internal_client_load(jack_client_t* ext_client, const char* client_name, jack_options_t options, jack_status_t* status, ...)
00758 {
00759 va_list ap;
00760 va_start(ap, status);
00761 jack_intclient_t res = (*jack_internal_client_load_fun)(ext_client, client_name, options, status, ap);
00762 va_end(ap);
00763 return res;
00764 }
00765
00766 typedef jack_status_t (*jack_internal_client_unload_fun_def)(jack_client_t* ext_client, jack_intclient_t intclient);
00767 static jack_internal_client_unload_fun_def jack_internal_client_unload_fun = 0;
00768 EXPORT jack_status_t jack_internal_client_unload(jack_client_t* ext_client, jack_intclient_t intclient)
00769 {
00770 return (*jack_internal_client_unload_fun)(ext_client, intclient);
00771 }
00772
00773
00774 static long gClientCount = 0;
00775 static void* gLibrary = 0;
00776 static bool init_library();
00777 static bool open_library();
00778 static void close_library();
00779
00780 typedef jack_client_t * (*jack_client_open_fun_def)(const char *client_name, jack_options_t options, jack_status_t *status, ...);
00781 static jack_client_open_fun_def jack_client_open_fun = 0;
00782 EXPORT jack_client_t * jack_client_open(const char *client_name, jack_options_t options, jack_status_t *status, ...)
00783 {
00784
00785 if (!open_library())
00786 return 0;
00787
00788 va_list ap;
00789 va_start(ap, status);
00790 jack_client_t* res = (*jack_client_open_fun)(client_name, options, status, ap);
00791 va_end(ap);
00792 return res;
00793 }
00794
00795 typedef jack_client_t * (*jack_client_new_fun_def)(const char *client_name);
00796 static jack_client_new_fun_def jack_client_new_fun = 0;
00797 EXPORT jack_client_t * jack_client_new(const char *client_name)
00798 {
00799
00800 if (!open_library())
00801 return 0;
00802
00803 return (*jack_client_new_fun)(client_name);
00804 }
00805
00806 typedef int (*jack_client_close_fun_def)(jack_client_t *client);
00807 static jack_client_close_fun_def jack_client_close_fun = 0;
00808 EXPORT int jack_client_close(jack_client_t *client)
00809 {
00810 int res = (*jack_client_close_fun)(client);
00811 close_library();
00812 return res;
00813 }
00814
00815
00816 static bool get_jack_library_in_directory(char* dir_name, char* library_name)
00817 {
00818 struct dirent * dir_entry;
00819 DIR * dir_stream = opendir(dir_name);
00820 if (!dir_stream)
00821 return false;
00822
00823 while ((dir_entry = readdir(dir_stream))) {
00824 if (strncmp("libjack.so", dir_entry->d_name, 10) == 0) {
00825 strcpy(library_name, dir_entry->d_name);
00826 closedir(dir_stream);
00827 return true;
00828 }
00829 }
00830 closedir(dir_stream);
00831 return false;
00832 }
00833
00834 static bool get_jack_library(char* library_name)
00835 {
00836 if (get_jack_library_in_directory("/usr/lib", library_name))
00837 return true;
00838 if (get_jack_library_in_directory("/usr/local/lib", library_name))
00839 return true;
00840 return false;
00841 }
00842
00843 static bool open_library()
00844 {
00845 if (gClientCount++ == 0) {
00846 return init_library();
00847 } else {
00848 return true;
00849 }
00850 }
00851
00852 static void close_library()
00853 {
00854 if (--gClientCount == 0) {
00855 dlclose(gLibrary);
00856 }
00857 }
00858
00859 static bool check_client(void* library)
00860 {
00861 jack_client_t* client = 0;
00862
00863
00864 jack_client_new_fun = (jack_client_new_fun_def)dlsym(library, "jack_client_new");
00865 jack_client_close_fun = (jack_client_close_fun_def)dlsym(library, "jack_client_close");
00866 jack_client_open_fun = (jack_client_open_fun_def)dlsym(gLibrary, "jack_client_open");
00867
00868
00869 if ((client = (*jack_client_new_fun)("dummy"))) {
00870 (*jack_client_close_fun)(client);
00871 return true;
00872 } else {
00873 return false;
00874 }
00875 }
00876
00877 static bool init_library()
00878 {
00879 char library_name[64];
00880 void* jackLibrary = (get_jack_library(library_name)) ? dlopen(library_name, RTLD_LAZY) : 0;
00881 void* jackmpLibrary = dlopen("libjackmp.so", RTLD_LAZY);
00882
00883 if (jackLibrary) {
00884
00885 if (check_client(jackLibrary)) {
00886 gLibrary = jackLibrary;
00887 if (jackmpLibrary) dlclose(jackmpLibrary);
00888 } else if (check_client(jackmpLibrary)) {
00889 gLibrary = jackmpLibrary;
00890 if (jackLibrary) dlclose(jackLibrary);
00891 } else {
00892 goto error;
00893 }
00894
00895 } else if (jackmpLibrary) {
00896
00897 if (check_client(jackmpLibrary)) {
00898 gLibrary = jackmpLibrary;
00899 } else {
00900 goto error;
00901 }
00902
00903 } else {
00904 printf("Jack libraries not found, failure...\n");
00905 goto error;
00906 }
00907
00908
00909 jack_port_get_buffer_fun = (jack_port_get_buffer_fun_def)dlsym(gLibrary, "jack_port_get_buffer");
00910 jack_port_name_fun = (jack_port_name_fun_def)dlsym(gLibrary, "jack_port_name");
00911 jack_port_short_name_fun = (jack_port_short_name_fun_def)dlsym(gLibrary, "jack_port_short_name");
00912 jack_port_flags_fun = (jack_port_flags_fun_def)dlsym(gLibrary, "jack_port_flags");
00913 jack_port_type_fun = (jack_port_type_fun_def)dlsym(gLibrary, "jack_port_type");
00914 jack_port_connected_fun = (jack_port_connected_fun_def)dlsym(gLibrary, "jack_port_connected");
00915 jack_port_connected_to_fun = (jack_port_connected_to_fun_def)dlsym(gLibrary, "jack_port_connected_to");
00916 jack_port_tie_fun = (jack_port_tie_fun_def)dlsym(gLibrary, "jack_port_tie");
00917 jack_port_untie_fun = (jack_port_untie_fun_def)dlsym(gLibrary, "jack_port_untie");
00918 jack_port_get_latency_fun = (jack_port_get_latency_fun_def)dlsym(gLibrary, "jack_port_get_latency");
00919 jack_port_set_latency_fun = (jack_port_set_latency_fun_def)dlsym(gLibrary, "jack_port_set_latency");
00920 jack_recompute_total_latencies_fun = (jack_recompute_total_latencies_fun_def)dlsym(gLibrary, "jack_recompute_total_latencies");
00921 jack_port_set_name_fun = (jack_port_set_name_fun_def)dlsym(gLibrary, "jack_port_set_name");
00922 jack_port_request_monitor_fun = (jack_port_request_monitor_fun_def)dlsym(gLibrary, "jack_port_request_monitor");
00923 jack_port_request_monitor_by_name_fun = (jack_port_request_monitor_by_name_fun_def)dlsym(gLibrary, "jack_port_request_monitor_by_name");
00924 jack_port_ensure_monitor_fun = (jack_port_ensure_monitor_fun_def)dlsym(gLibrary, "jack_port_ensure_monitor");
00925 jack_port_monitoring_input_fun = (jack_port_monitoring_input_fun_def)dlsym(gLibrary, "jack_port_monitoring_input_fun");
00926 jack_is_realtime_fun = (jack_is_realtime_fun_def)dlsym(gLibrary, "jack_is_realtime");
00927 jack_on_shutdown_fun = (jack_on_shutdown_fun_def)dlsym(gLibrary, "jack_on_shutdown");
00928 jack_set_process_callback_fun = (jack_set_process_callback_fun_def)dlsym(gLibrary, "jack_set_process_callback");
00929 jack_set_freewheel_callback_fun = (jack_set_freewheel_callback_fun_def)dlsym(gLibrary, "jack_set_freewheel_callback");
00930 jack_set_freewheel_fun = (jack_set_freewheel_fun_def)dlsym(gLibrary, "jack_set_freewheel");
00931 jack_set_buffer_size_fun = (jack_set_buffer_size_fun_def)dlsym(gLibrary, "jack_set_buffer_size");
00932 jack_set_buffer_size_callback_fun = (jack_set_buffer_size_callback_fun_def)dlsym(gLibrary, "jack_set_buffer_size_callback");
00933 jack_set_sample_rate_callback_fun = (jack_set_sample_rate_callback_fun_def)dlsym(gLibrary, "jack_set_sample_rate_callback");
00934 jack_set_port_registration_callback_fun = (jack_set_port_registration_callback_fun_def)dlsym(gLibrary, "jack_set_port_registration_callback");
00935 jack_set_graph_order_callback_fun = (jack_set_graph_order_callback_fun_def)dlsym(gLibrary, "jack_set_graph_order_callback");
00936 jack_set_xrun_callback_fun = (jack_set_xrun_callback_fun_def)dlsym(gLibrary, "jack_set_xrun_callback");
00937 jack_set_thread_init_callback_fun = (jack_set_thread_init_callback_fun_def)dlsym(gLibrary, "jack_set_thread_init_callback");
00938 jack_activate_fun = (jack_activate_fun_def)dlsym(gLibrary, "jack_activate");
00939 jack_deactivate_fun = (jack_deactivate_fun_def)dlsym(gLibrary, "jack_deactivate");
00940 jack_port_register_fun = (jack_port_register_fun_def)dlsym(gLibrary, "jack_port_register");
00941 jack_port_unregister_fun = (jack_port_unregister_fun_def)dlsym(gLibrary, "jack_port_unregister");
00942 jack_port_is_mine_fun = (jack_port_is_mine_fun_def)dlsym(gLibrary, "jack_port_is_mine");
00943 jack_port_get_connections_fun = (jack_port_get_connections_fun_def)dlsym(gLibrary, "jack_port_get_connections");
00944 jack_port_get_all_connections_fun = (jack_port_get_all_connections_fun_def)dlsym(gLibrary, "jack_port_get_all_connections_fun");
00945 jack_port_lock_fun = (jack_port_lock_fun_def)dlsym(gLibrary, "jack_port_lock");
00946 jack_port_unlock_fun = (jack_port_unlock_fun_def)dlsym(gLibrary, "jack_port_unlock");
00947 jack_port_get_total_latency_fun = (jack_port_get_total_latency_fun_def)dlsym(gLibrary, "jack_port_get_total_latency");
00948 jack_connect_fun = (jack_connect_fun_def)dlsym(gLibrary, "jack_connect");
00949 jack_disconnect_fun = (jack_disconnect_fun_def)dlsym(gLibrary, "jack_disconnect");
00950 jack_port_connect_fun = (jack_port_connect_fun_def)dlsym(gLibrary, "jack_port_connect");
00951 jack_port_disconnect_fun = (jack_port_disconnect_fun_def)dlsym(gLibrary, "jack_port_disconnect");
00952 jack_get_sample_rate_fun = (jack_get_sample_rate_fun_def)dlsym(gLibrary, "jack_get_sample_rate");
00953 jack_get_buffer_size_fun = (jack_get_buffer_size_fun_def)dlsym(gLibrary, "jack_get_buffer_size");
00954 jack_get_ports_fun = (jack_get_ports_fun_def)dlsym(gLibrary, "jack_get_ports");
00955 jack_port_by_name_fun = (jack_port_by_name_fun_def)dlsym(gLibrary, "jack_port_by_name");
00956 jack_port_by_id_fun = (jack_port_by_id_fun_def)dlsym(gLibrary, "jack_port_by_id");
00957 jack_engine_takeover_timebase_fun = (jack_engine_takeover_timebase_fun_def)dlsym(gLibrary, "jack_engine_takeover_timebase");
00958 jack_frames_since_cycle_start_fun = (jack_frames_since_cycle_start_fun_def)dlsym(gLibrary, "jack_frames_since_cycle_start");
00959 jack_frame_time_fun = (jack_frame_time_fun_def)dlsym(gLibrary, "jack_frame_time_fun");
00960 jack_last_frame_time_fun = (jack_last_frame_time_fun_def)dlsym(gLibrary, "jack_last_frame_time");
00961 jack_cpu_load_fun = (jack_cpu_load_fun_def)dlsym(gLibrary, "jack_cpu_load");
00962 jack_client_thread_id_fun = (jack_client_thread_id_fun_def)dlsym(gLibrary, "jack_client_thread_id");
00963 jack_get_client_name_fun = (jack_get_client_name_fun_def)dlsym(gLibrary, "jack_get_client_name");
00964 jack_port_name_size_fun = (jack_port_name_size_fun_def)dlsym(gLibrary, "jack_port_name_size");
00965 jack_client_name_size_fun = (jack_client_name_size_fun_def)dlsym(gLibrary, "jack_client_name_size");
00966 jack_release_timebase_fun = (jack_release_timebase_fun_def)dlsym(gLibrary, "jack_release_timebase");
00967 jack_set_sync_callback_fun = (jack_set_sync_callback_fun_def)dlsym(gLibrary, "jack_set_sync_callback");
00968 jack_set_sync_timeout_fun = (jack_set_sync_timeout_fun_def)dlsym(gLibrary, "jack_set_sync_timeout");
00969 jack_set_timebase_callback_fun = (jack_set_timebase_callback_fun_def)dlsym(gLibrary, "jack_set_timebase_callback");
00970 jack_transport_locate_fun = (jack_transport_locate_fun_def)dlsym(gLibrary, "jack_transport_locate_fun");
00971 jack_transport_query_fun = (jack_transport_query_fun_def)dlsym(gLibrary, "jack_transport_query");
00972 jack_get_current_transport_frame_fun = (jack_get_current_transport_frame_fun_def)dlsym(gLibrary, "jack_get_current_transport_frame");
00973 jack_transport_reposition_fun = (jack_transport_reposition_fun_def)dlsym(gLibrary, "jack_transport_reposition");
00974 jack_transport_start_fun = (jack_transport_start_fun_def)dlsym(gLibrary, "jack_transport_start");
00975 jack_transport_stop_fun = (jack_transport_stop_fun_def)dlsym(gLibrary, "jack_transport_stop");
00976 jack_get_transport_info_fun = (jack_get_transport_info_fun_def)dlsym(gLibrary, "jack_get_transport_info");
00977 jack_set_transport_info_fun = (jack_set_transport_info_fun_def)dlsym(gLibrary, "jack_set_transport_info");
00978 jack_get_max_delayed_usecs_fun = (jack_get_max_delayed_usecs_fun_def)dlsym(gLibrary, "jack_get_max_delayed_usecs");
00979 jack_get_xrun_delayed_usecs_fun = (jack_get_xrun_delayed_usecs_fun_def)dlsym(gLibrary, "jack_get_xrun_delayed_usecs");
00980 jack_reset_max_delayed_usecs_fun = (jack_reset_max_delayed_usecs_fun_def)dlsym(gLibrary, "jack_reset_max_delayed_usecs");
00981 jack_acquire_real_time_scheduling_fun = (jack_acquire_real_time_scheduling_fun_def)dlsym(gLibrary, "jack_acquire_real_time_scheduling");
00982 jack_client_create_thread_fun = (jack_client_create_thread_fun_def)dlsym(gLibrary, "jack_client_create_thread");
00983 jack_drop_real_time_scheduling_fun = (jack_drop_real_time_scheduling_fun_def)dlsym(gLibrary, "jack_drop_real_time_scheduling");
00984 jack_get_internal_client_name_fun = (jack_get_internal_client_name_fun_def)dlsym(gLibrary, "jack_get_internal_client_name");
00985 jack_internal_client_handle_fun = (jack_internal_client_handle_fun_def)dlsym(gLibrary, "jack_internal_client_handle");
00986 jack_internal_client_load_fun = (jack_internal_client_load_fun_def)dlsym(gLibrary, "jack_internal_client_load");
00987 jack_internal_client_unload_fun = (jack_internal_client_unload_fun_def)dlsym(gLibrary, "jack_internal_client_unload");
00988 jack_client_open_fun = (jack_client_open_fun_def)dlsym(gLibrary, "jack_client_open");
00989 jack_client_new_fun = (jack_client_new_fun_def)dlsym(gLibrary, "jack_client_new");
00990 jack_client_close_fun = (jack_client_close_fun_def)dlsym(gLibrary, "jack_client_close");
00991
00992 return true;
00993
00994 error:
00995 if (jackLibrary) dlclose(jackLibrary);
00996 if (jackmpLibrary) dlclose(jackmpLibrary);
00997 return false;
00998 }