JackAPIWrapper.cpp

00001 /*
00002 Copyright (C) 2006 Grame
00003 
00004 This program is free software; you can redistribute it and/or modify
00005 it under the terms of the GNU General Public License as published by
00006 the Free Software Foundation; either version 2 of the License, or
00007 (at your option) any later version.
00008 
00009 This program is distributed in the hope that it will be useful,
00010 but WITHOUT ANY WARRANTY; without even the implied warranty of
00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012 GNU General Public License for more details.
00013 
00014 You should have received a copy of the GNU General Public License
00015 along with this program; if not, write to the Free Software
00016 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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,         // boolean
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 // Function definition
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 // Calling client does not need to "own" the port
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 // Does not use the client parameter
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 // Does not use the client parameter
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 // transport.h
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 // deprecated
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 // statistics.h
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 // thread.h
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,   // boolean 
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,      // boolean 
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 // intclient.h
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 // client
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         // Library check...
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         // Library check...
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 // Library loader
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         // Get "new", "open" and "close" entry points...
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         // Try opening a client...
00869         if ((client = (*jack_client_new_fun)("dummy"))) { // jackd server is running....
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)) { // jackd is running...
00886                         gLibrary = jackLibrary;
00887                         if (jackmpLibrary) dlclose(jackmpLibrary);
00888                 } else if (check_client(jackmpLibrary)) { // jackdmp is running...
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)) { // jackd is running...
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         // Load entry points...
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 }

Generated on Wed Jan 10 11:42:43 2007 for Jackdmp by  doxygen 1.4.5