Jack2: JackAPI.cpp Source File

00001 /*
00002 Copyright (C) 2001-2003 Paul Davis
00003 Copyright (C) 2004-2008 Grame
00004 
00005 This program is free software; you can redistribute it and/or modify
00006 it under the terms of the GNU Lesser General Public License as published by
00007 the Free Software Foundation; either version 2.1 of the License, or
00008 (at your option) any later version.
00009 
00010 This program is distributed in the hope that it will be useful,
00011 but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 GNU Lesser General Public License for more details.
00014 
00015 You should have received a copy of the GNU Lesser General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00018 
00019 */
00020 
00021 #include "JackClient.h"
00022 #include "JackError.h"
00023 #include "JackGraphManager.h"
00024 #include "JackEngineControl.h"
00025 #include "JackClientControl.h"
00026 #include "JackGlobals.h"
00027 #include "JackTime.h"
00028 #include "JackPortType.h"
00029 #include "JackMetadata.h"
00030 #include <math.h>
00031 
00032 using namespace Jack;
00033 
00034 #ifdef __cplusplus
00035 extern "C"
00036 {
00037 #endif
00038 
00039     typedef void (*print_function)(const char*);
00040     typedef void *(*thread_routine)(void*);
00041 
00042     LIB_EXPORT const char* JACK_METADATA_PRETTY_NAME = "http://jackaudio.org/metadata/pretty-name";
00043     LIB_EXPORT const char* JACK_METADATA_HARDWARE = "http://jackaudio.org/metadata/hardware";
00044     LIB_EXPORT const char* JACK_METADATA_CONNECTED = "http://jackaudio.org/metadata/connected";
00045     LIB_EXPORT const char* JACK_METADATA_PORT_GROUP = "http://jackaudio.org/metadata/port-group";
00046     LIB_EXPORT const char* JACK_METADATA_ICON_SMALL = "http://jackaudio.org/metadata/icon-small";
00047     LIB_EXPORT const char* JACK_METADATA_ICON_LARGE = "http://jackaudio.org/metadata/icon-large";
00048 
00049     LIB_EXPORT
00050     void
00051     jack_get_version(
00052         int *major_ptr,
00053         int *minor_ptr,
00054         int *micro_ptr,
00055         int *proto_ptr);
00056 
00057     LIB_EXPORT
00058     const char*
00059     jack_get_version_string();
00060 
00061     jack_client_t * jack_client_new_aux(const char* client_name,
00062             jack_options_t options,
00063             jack_status_t *status);
00064 
00065     LIB_EXPORT jack_client_t * jack_client_open(const char* client_name,
00066             jack_options_t options,
00067             jack_status_t *status, ...);
00068     LIB_EXPORT jack_client_t * jack_client_new(const char* client_name);
00069     LIB_EXPORT int jack_client_name_size(void);
00070     LIB_EXPORT char* jack_get_client_name(jack_client_t *client);
00071     LIB_EXPORT int jack_internal_client_new(const char* client_name,
00072                                          const char* load_name,
00073                                          const char* load_init);
00074     LIB_EXPORT void jack_internal_client_close(const char* client_name);
00075     LIB_EXPORT int jack_is_realtime(jack_client_t *client);
00076     LIB_EXPORT void jack_on_shutdown(jack_client_t *client,
00077                                   JackShutdownCallback shutdown_callback, void *arg);
00078     LIB_EXPORT void jack_on_info_shutdown(jack_client_t *client,
00079                                   JackInfoShutdownCallback shutdown_callback, void *arg);
00080     LIB_EXPORT int jack_set_process_callback(jack_client_t *client,
00081                                           JackProcessCallback process_callback,
00082                                           void *arg);
00083     LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t *client, int status);
00084 
00085     // new
00086     LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t*);
00087     LIB_EXPORT void jack_cycle_signal(jack_client_t*, int status);
00088     LIB_EXPORT int jack_set_process_thread(jack_client_t* client, JackThreadCallback fun, void *arg);
00089 
00090     LIB_EXPORT int jack_set_thread_init_callback(jack_client_t *client,
00091             JackThreadInitCallback thread_init_callback,
00092             void *arg);
00093     LIB_EXPORT int jack_set_freewheel_callback(jack_client_t *client,
00094                                             JackFreewheelCallback freewheel_callback,
00095                                             void *arg);
00096     LIB_EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);
00097     LIB_EXPORT int jack_set_buffer_size(jack_client_t *client, jack_nframes_t nframes);
00098     LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t *client,
00099             JackBufferSizeCallback bufsize_callback,
00100             void *arg);
00101     LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t *client,
00102             JackSampleRateCallback srate_callback,
00103             void *arg);
00104     LIB_EXPORT int jack_set_client_registration_callback(jack_client_t *,
00105             JackClientRegistrationCallback
00106             registration_callback, void *arg);
00107     LIB_EXPORT int jack_set_port_registration_callback(jack_client_t *,
00108             JackPortRegistrationCallback
00109             registration_callback, void *arg);
00110     LIB_EXPORT int jack_set_port_connect_callback(jack_client_t *,
00111             JackPortConnectCallback
00112             connect_callback, void *arg);
00113     LIB_EXPORT int jack_set_port_rename_callback(jack_client_t *,
00114                                     JackPortRenameCallback
00115                                     rename_callback, void *arg);
00116     LIB_EXPORT int jack_set_graph_order_callback(jack_client_t *,
00117             JackGraphOrderCallback graph_callback,
00118             void *);
00119     LIB_EXPORT int jack_set_xrun_callback(jack_client_t *,
00120                                        JackXRunCallback xrun_callback, void *arg);
00121     LIB_EXPORT int jack_set_latency_callback(jack_client_t *client,
00122                                JackLatencyCallback latency_callback, void *arg);
00123 
00124     LIB_EXPORT int jack_activate(jack_client_t *client);
00125     LIB_EXPORT int jack_deactivate(jack_client_t *client);
00126     LIB_EXPORT jack_port_t * jack_port_register(jack_client_t *client,
00127             const char* port_name,
00128             const char* port_type,
00129             unsigned long flags,
00130             unsigned long buffer_size);
00131     LIB_EXPORT int jack_port_unregister(jack_client_t *, jack_port_t *);
00132     LIB_EXPORT void * jack_port_get_buffer(jack_port_t *, jack_nframes_t);
00133     LIB_EXPORT jack_uuid_t  jack_port_uuid(const jack_port_t*);
00134     LIB_EXPORT const char*  jack_port_name(const jack_port_t *port);
00135     LIB_EXPORT const char*  jack_port_short_name(const jack_port_t *port);
00136     LIB_EXPORT int jack_port_flags(const jack_port_t *port);
00137     LIB_EXPORT const char*  jack_port_type(const jack_port_t *port);
00138     LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port);
00139     LIB_EXPORT int jack_port_is_mine(const jack_client_t *, const jack_port_t *port);
00140     LIB_EXPORT int jack_port_connected(const jack_port_t *port);
00141     LIB_EXPORT int jack_port_connected_to(const jack_port_t *port,
00142                                        const char* port_name);
00143     LIB_EXPORT const char* * jack_port_get_connections(const jack_port_t *port);
00144     LIB_EXPORT const char* * jack_port_get_all_connections(const jack_client_t *client,
00145             const jack_port_t *port);
00146     LIB_EXPORT int jack_port_tie(jack_port_t *src, jack_port_t *dst);
00147     LIB_EXPORT int jack_port_untie(jack_port_t *port);
00148 
00149     // Old latency API
00150     LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t *port);
00151     LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t *,
00152             jack_port_t *port);
00153     LIB_EXPORT void jack_port_set_latency(jack_port_t *, jack_nframes_t);
00154     LIB_EXPORT int jack_recompute_total_latency(jack_client_t*, jack_port_t* port);
00155 
00156     // New latency API
00157     LIB_EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);
00158     LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);
00159     LIB_EXPORT int jack_recompute_total_latencies(jack_client_t*);
00160 
00161     LIB_EXPORT int jack_port_set_name(jack_port_t *port, const char* port_name);
00162     LIB_EXPORT int jack_port_set_alias(jack_port_t *port, const char* alias);
00163     LIB_EXPORT int jack_port_unset_alias(jack_port_t *port, const char* alias);
00164     LIB_EXPORT int jack_port_get_aliases(const jack_port_t *port, char* const aliases[2]);
00165     LIB_EXPORT int jack_port_request_monitor(jack_port_t *port, int onoff);
00166     LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t *client,
00167             const char* port_name, int onoff);
00168     LIB_EXPORT int jack_port_ensure_monitor(jack_port_t *port, int onoff);
00169     LIB_EXPORT int jack_port_monitoring_input(jack_port_t *port);
00170     LIB_EXPORT int jack_connect(jack_client_t *,
00171                              const char* source_port,
00172                              const char* destination_port);
00173     LIB_EXPORT int jack_disconnect(jack_client_t *,
00174                                 const char* source_port,
00175                                 const char* destination_port);
00176     LIB_EXPORT int jack_port_disconnect(jack_client_t *, jack_port_t *);
00177     LIB_EXPORT int jack_port_name_size(void);
00178     LIB_EXPORT int jack_port_type_size(void);
00179     LIB_EXPORT size_t jack_port_type_get_buffer_size(jack_client_t *client, const char* port_type);
00180     LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t *);
00181     LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t *);
00182     LIB_EXPORT const char* * jack_get_ports(jack_client_t *,
00183                                          const char* port_name_pattern,
00184                                          const char* type_name_pattern,
00185                                          unsigned long flags);
00186     LIB_EXPORT jack_port_t * jack_port_by_name(jack_client_t *, const char* port_name);
00187     LIB_EXPORT jack_port_t * jack_port_by_id(jack_client_t *client,
00188                                           jack_port_id_t port_id);
00189     LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t *);
00190     LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t *);
00191     LIB_EXPORT jack_time_t jack_get_time();
00192     LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t usecs);
00193     LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames);
00194     LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t *);
00195     LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t *client);
00196     LIB_EXPORT int jack_get_cycle_times(const jack_client_t *client,
00197                                         jack_nframes_t *current_frames,
00198                                         jack_time_t    *current_usecs,
00199                                         jack_time_t    *next_usecs,
00200                                         float          *period_usecs);
00201     LIB_EXPORT float jack_cpu_load(jack_client_t *client);
00202     LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t *);
00203     LIB_EXPORT void jack_set_error_function(print_function);
00204     LIB_EXPORT void jack_set_info_function(print_function);
00205 
00206     LIB_EXPORT float jack_get_max_delayed_usecs(jack_client_t *client);
00207     LIB_EXPORT float jack_get_xrun_delayed_usecs(jack_client_t *client);
00208     LIB_EXPORT void jack_reset_max_delayed_usecs(jack_client_t *client);
00209 
00210     LIB_EXPORT int jack_release_timebase(jack_client_t *client);
00211     LIB_EXPORT int jack_set_sync_callback(jack_client_t *client,
00212                                        JackSyncCallback sync_callback,
00213                                        void *arg);
00214     LIB_EXPORT int jack_set_sync_timeout(jack_client_t *client,
00215                                       jack_time_t timeout);
00216     LIB_EXPORT int jack_set_timebase_callback(jack_client_t *client,
00217                                            int conditional,
00218                                            JackTimebaseCallback timebase_callback,
00219                                            void *arg);
00220     LIB_EXPORT int jack_transport_locate(jack_client_t *client,
00221                                       jack_nframes_t frame);
00222     LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t *client,
00223             jack_position_t *pos);
00224     LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t *client);
00225     LIB_EXPORT int jack_transport_reposition(jack_client_t *client,
00226                                           const jack_position_t *pos);
00227     LIB_EXPORT void jack_transport_start(jack_client_t *client);
00228     LIB_EXPORT void jack_transport_stop(jack_client_t *client);
00229     LIB_EXPORT void jack_get_transport_info(jack_client_t *client,
00230                                          jack_transport_info_t *tinfo);
00231     LIB_EXPORT void jack_set_transport_info(jack_client_t *client,
00232                                          jack_transport_info_t *tinfo);
00233 
00234     LIB_EXPORT int jack_client_real_time_priority(jack_client_t*);
00235     LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t*);
00236     LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority);
00237     LIB_EXPORT int jack_client_create_thread(jack_client_t* client,
00238                                           jack_native_thread_t *thread,
00239                                           int priority,
00240                                           int realtime,         // boolean
00241                                           thread_routine routine,
00242                                           void *arg);
00243     LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread);
00244 
00245     LIB_EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread);
00246     LIB_EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread);
00247 #ifndef WIN32
00248     LIB_EXPORT void jack_set_thread_creator(jack_thread_creator_t jtc);
00249 #endif
00250     LIB_EXPORT char * jack_get_internal_client_name(jack_client_t *client,
00251             jack_intclient_t intclient);
00252     LIB_EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t *client,
00253             const char* client_name,
00254             jack_status_t *status);
00255     LIB_EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client,
00256             const char* client_name,
00257             jack_options_t options,
00258             jack_status_t *status, ...);
00259 
00260     LIB_EXPORT jack_status_t jack_internal_client_unload(jack_client_t *client,
00261             jack_intclient_t intclient);
00262     LIB_EXPORT void jack_free(void* ptr);
00263 
00264     LIB_EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg);
00265     LIB_EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char* path);
00266     LIB_EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event);
00267     LIB_EXPORT void jack_session_event_free(jack_session_event_t* ev);
00268     LIB_EXPORT char* jack_client_get_uuid (jack_client_t *client);
00269     LIB_EXPORT char* jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name);
00270     LIB_EXPORT char* jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid);
00271     LIB_EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* name, const char* uuid);
00272     LIB_EXPORT void jack_session_commands_free(jack_session_command_t *cmds);
00273     LIB_EXPORT int jack_client_has_session_callback(jack_client_t *client, const char* client_name);
00274 
00275     LIB_EXPORT int jack_set_property(jack_client_t*, jack_uuid_t subject, const char* key, const char* value, const char* type);
00276     LIB_EXPORT int jack_get_property(jack_uuid_t subject, const char* key, char** value, char** type);
00277     LIB_EXPORT void jack_free_description(jack_description_t* desc, int free_description_itself);
00278     LIB_EXPORT int jack_get_properties(jack_uuid_t subject, jack_description_t* desc);
00279     LIB_EXPORT int jack_get_all_properties(jack_description_t** descs);
00280     LIB_EXPORT int jack_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key);
00281     LIB_EXPORT int jack_remove_properties(jack_client_t* client, jack_uuid_t subject);
00282     LIB_EXPORT int jack_remove_all_properties(jack_client_t* client);
00283     LIB_EXPORT int jack_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg);
00284 
00285     LIB_EXPORT jack_uuid_t jack_client_uuid_generate();
00286     LIB_EXPORT jack_uuid_t jack_port_uuid_generate(uint32_t port_id);
00287     LIB_EXPORT uint32_t jack_uuid_to_index(jack_uuid_t);
00288     LIB_EXPORT int  jack_uuid_compare(jack_uuid_t, jack_uuid_t);
00289     LIB_EXPORT void jack_uuid_copy(jack_uuid_t* dst, jack_uuid_t src);
00290     LIB_EXPORT void jack_uuid_clear(jack_uuid_t*);
00291     LIB_EXPORT int  jack_uuid_parse(const char* buf, jack_uuid_t*);
00292     LIB_EXPORT void jack_uuid_unparse(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);
00293     LIB_EXPORT int  jack_uuid_empty(jack_uuid_t);
00294 
00295 #ifdef __cplusplus
00296 }
00297 #endif
00298 
00299 static inline bool CheckPort(jack_port_id_t port_index)
00300 {
00301     return (port_index > 0 && port_index < PORT_NUM_MAX);
00302 }
00303 
00304 static inline bool CheckBufferSize(jack_nframes_t buffer_size)
00305 {
00306     return (buffer_size >= 1 && buffer_size <= BUFFER_SIZE_MAX);
00307 }
00308 
00309 static inline void WaitGraphChange()
00310 {
00311     /*
00312     TLS key that is set only in RT thread, so never waits for pending
00313     graph change in RT context (just read the current graph state).
00314     */
00315 
00316     if (jack_tls_get(JackGlobals::fRealTimeThread) == NULL) {
00317         JackGraphManager* manager = GetGraphManager();
00318         JackEngineControl* control = GetEngineControl();
00319         assert(manager);
00320         assert(control);
00321         if (manager->IsPendingChange()) {
00322             jack_log("WaitGraphChange...");
00323             JackSleep(int(control->fPeriodUsecs * 1.1f));
00324         }
00325     }
00326 }
00327 
00328 LIB_EXPORT void jack_set_error_function(print_function func)
00329 {
00330     jack_error_callback = (func == NULL) ? &default_jack_error_callback : func;
00331 }
00332 
00333 LIB_EXPORT void jack_set_info_function(print_function func)
00334 {
00335     jack_info_callback = (func == NULL) ? &default_jack_info_callback : func;
00336 }
00337 
00338 LIB_EXPORT jack_client_t* jack_client_new(const char* client_name)
00339 {
00340     JackGlobals::CheckContext("jack_client_new");
00341 
00342     try {
00343         assert(JackGlobals::fOpenMutex);
00344         JackGlobals::fOpenMutex->Lock();
00345         jack_error("jack_client_new: deprecated");
00346         int options = JackUseExactName;
00347         if (getenv("JACK_START_SERVER") == NULL) {
00348             options |= JackNoStartServer;
00349         }
00350         jack_client_t* res = jack_client_new_aux(client_name, (jack_options_t)options, NULL);
00351         JackGlobals::fOpenMutex->Unlock();
00352         return res;
00353     } catch (std::bad_alloc& e) {
00354         jack_error("Memory allocation error...");
00355         return NULL;
00356     } catch (...) {
00357         jack_error("Unknown error...");
00358         return NULL;
00359     }
00360 }
00361 
00362 LIB_EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)
00363 {
00364     JackGlobals::CheckContext("jack_port_get_buffer");
00365 
00366     uintptr_t port_aux = (uintptr_t)port;
00367     jack_port_id_t myport = (jack_port_id_t)port_aux;
00368     if (!CheckPort(myport)) {
00369         jack_error("jack_port_get_buffer called with an incorrect port %ld", myport);
00370         return NULL;
00371     } else {
00372         JackGraphManager* manager = GetGraphManager();
00373         return (manager ? manager->GetBuffer(myport, frames) : NULL);
00374     }
00375 }
00376 
00377 LIB_EXPORT jack_uuid_t jack_port_uuid(const jack_port_t*)
00378 {
00379     return 0;
00380 }
00381 
00382 LIB_EXPORT const char* jack_port_name(const jack_port_t* port)
00383 {
00384     JackGlobals::CheckContext("jack_port_name");
00385 
00386     uintptr_t port_aux = (uintptr_t)port;
00387     jack_port_id_t myport = (jack_port_id_t)port_aux;
00388     if (!CheckPort(myport)) {
00389         jack_error("jack_port_name called with an incorrect port %ld", myport);
00390         return NULL;
00391     } else {
00392         JackGraphManager* manager = GetGraphManager();
00393         return (manager ? manager->GetPort(myport)->GetName() : NULL);
00394     }
00395 }
00396 
00397 LIB_EXPORT const char* jack_port_short_name(const jack_port_t* port)
00398 {
00399     JackGlobals::CheckContext("jack_port_short_name");
00400 
00401     uintptr_t port_aux = (uintptr_t)port;
00402     jack_port_id_t myport = (jack_port_id_t)port_aux;
00403     if (!CheckPort(myport)) {
00404         jack_error("jack_port_short_name called with an incorrect port %ld", myport);
00405         return NULL;
00406     } else {
00407         JackGraphManager* manager = GetGraphManager();
00408         return (manager ? manager->GetPort(myport)->GetShortName() : NULL);
00409     }
00410 }
00411 
00412 LIB_EXPORT int jack_port_flags(const jack_port_t* port)
00413 {
00414     JackGlobals::CheckContext("jack_port_flags");
00415 
00416     uintptr_t port_aux = (uintptr_t)port;
00417     jack_port_id_t myport = (jack_port_id_t)port_aux;
00418     if (!CheckPort(myport)) {
00419         jack_error("jack_port_flags called with an incorrect port %ld", myport);
00420         return -1;
00421     } else {
00422         JackGraphManager* manager = GetGraphManager();
00423         return (manager ? manager->GetPort(myport)->GetFlags() : -1);
00424     }
00425 }
00426 
00427 LIB_EXPORT const char* jack_port_type(const jack_port_t* port)
00428 {
00429     JackGlobals::CheckContext("jack_port_type");
00430 
00431     uintptr_t port_aux = (uintptr_t)port;
00432     jack_port_id_t myport = (jack_port_id_t)port_aux;
00433     if (!CheckPort(myport)) {
00434         jack_error("jack_port_flags called an incorrect port %ld", myport);
00435         return NULL;
00436     } else {
00437         JackGraphManager* manager = GetGraphManager();
00438         return (manager ? manager->GetPort(myport)->GetType() : NULL);
00439     }
00440 }
00441 
00442 LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port)
00443 {
00444     JackGlobals::CheckContext("jack_port_type_id");
00445 
00446     uintptr_t port_aux = (uintptr_t)port;
00447     jack_port_id_t myport = (jack_port_id_t)port_aux;
00448     if (!CheckPort(myport)) {
00449         jack_error("jack_port_type_id called an incorrect port %ld", myport);
00450         return 0;
00451     } else {
00452         JackGraphManager* manager = GetGraphManager();
00453         return (manager ? GetPortTypeId(manager->GetPort(myport)->GetType()) : 0);
00454     }
00455 }
00456 
00457 LIB_EXPORT int jack_port_connected(const jack_port_t* port)
00458 {
00459     JackGlobals::CheckContext("jack_port_connected");
00460 
00461     uintptr_t port_aux = (uintptr_t)port;
00462     jack_port_id_t myport = (jack_port_id_t)port_aux;
00463     if (!CheckPort(myport)) {
00464         jack_error("jack_port_connected called with an incorrect port %ld", myport);
00465         return -1;
00466     } else {
00467         WaitGraphChange();
00468         JackGraphManager* manager = GetGraphManager();
00469         return (manager ? manager->GetConnectionsNum(myport) : -1);
00470     }
00471 }
00472 
00473 LIB_EXPORT int jack_port_connected_to(const jack_port_t* port, const char* port_name)
00474 {
00475     JackGlobals::CheckContext("jack_port_connected_to");
00476 
00477     uintptr_t port_aux = (uintptr_t)port;
00478     jack_port_id_t src = (jack_port_id_t)port_aux;
00479     if (!CheckPort(src)) {
00480         jack_error("jack_port_connected_to called with an incorrect port %ld", src);
00481         return -1;
00482     } else if (port_name == NULL) {
00483         jack_error("jack_port_connected_to called with a NULL port name");
00484         return -1;
00485     } else {
00486         WaitGraphChange();
00487         JackGraphManager* manager = GetGraphManager();
00488         jack_port_id_t dst = (manager ? manager->GetPort(port_name) : NO_PORT);
00489         if (dst == NO_PORT) {
00490             jack_error("Unknown destination port port_name = %s", port_name);
00491             return 0;
00492         } else {
00493             return manager->IsConnected(src, dst);
00494         }
00495     }
00496 }
00497 
00498 LIB_EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)
00499 {
00500     JackGlobals::CheckContext("jack_port_tie");
00501 
00502     uintptr_t src_aux = (uintptr_t)src;
00503     jack_port_id_t mysrc = (jack_port_id_t)src_aux;
00504     if (!CheckPort(mysrc)) {
00505         jack_error("jack_port_tie called with a NULL src port");
00506         return -1;
00507     }
00508     uintptr_t dst_aux = (uintptr_t)dst;
00509     jack_port_id_t mydst = (jack_port_id_t)dst_aux;
00510     if (!CheckPort(mydst)) {
00511         jack_error("jack_port_tie called with a NULL dst port");
00512         return -1;
00513     }
00514     JackGraphManager* manager = GetGraphManager();
00515     if (manager && manager->GetPort(mysrc)->GetRefNum() != manager->GetPort(mydst)->GetRefNum()) {
00516         jack_error("jack_port_tie called with ports not belonging to the same client");
00517         return -1;
00518     } else {
00519         return manager->GetPort(mydst)->Tie(mysrc);
00520     }
00521 }
00522 
00523 LIB_EXPORT int jack_port_untie(jack_port_t* port)
00524 {
00525     JackGlobals::CheckContext("jack_port_untie");
00526 
00527     uintptr_t port_aux = (uintptr_t)port;
00528     jack_port_id_t myport = (jack_port_id_t)port_aux;
00529     if (!CheckPort(myport)) {
00530         jack_error("jack_port_untie called with an incorrect port %ld", myport);
00531         return -1;
00532     } else {
00533         JackGraphManager* manager = GetGraphManager();
00534         return (manager ? manager->GetPort(myport)->UnTie() : -1);
00535     }
00536 }
00537 
00538 LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)
00539 {
00540     JackGlobals::CheckContext("jack_port_get_latency");
00541 
00542     uintptr_t port_aux = (uintptr_t)port;
00543     jack_port_id_t myport = (jack_port_id_t)port_aux;
00544     if (!CheckPort(myport)) {
00545         jack_error("jack_port_get_latency called with an incorrect port %ld", myport);
00546         return 0;
00547     } else {
00548         WaitGraphChange();
00549         JackGraphManager* manager = GetGraphManager();
00550         return (manager ? manager->GetPort(myport)->GetLatency() : 0);
00551     }
00552 }
00553 
00554 LIB_EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
00555 {
00556     JackGlobals::CheckContext("jack_port_set_latency");
00557 
00558     uintptr_t port_aux = (uintptr_t)port;
00559     jack_port_id_t myport = (jack_port_id_t)port_aux;
00560     if (!CheckPort(myport)) {
00561         jack_error("jack_port_set_latency called with an incorrect port %ld", myport);
00562     } else {
00563         JackGraphManager* manager = GetGraphManager();
00564         if (manager)
00565             manager->GetPort(myport)->SetLatency(frames);
00566     }
00567 }
00568 
00569 LIB_EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
00570 {
00571     JackGlobals::CheckContext("jack_port_get_latency_range");
00572 
00573     uintptr_t port_aux = (uintptr_t)port;
00574     jack_port_id_t myport = (jack_port_id_t)port_aux;
00575     if (!CheckPort(myport)) {
00576         jack_error("jack_port_get_latency_range called with an incorrect port %ld", myport);
00577     } else {
00578         WaitGraphChange();
00579         JackGraphManager* manager = GetGraphManager();
00580         if (manager)
00581             manager->GetPort(myport)->GetLatencyRange(mode, range);
00582     }
00583 }
00584 
00585 LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
00586 {
00587     JackGlobals::CheckContext("jack_port_set_latency_range");
00588 
00589     uintptr_t port_aux = (uintptr_t)port;
00590     jack_port_id_t myport = (jack_port_id_t)port_aux;
00591     if (!CheckPort(myport)) {
00592         jack_error("jack_port_set_latency_range called with an incorrect port %ld", myport);
00593     } else {
00594         WaitGraphChange();
00595         JackGraphManager* manager = GetGraphManager();
00596         if (manager)
00597             manager->GetPort(myport)->SetLatencyRange(mode, range);
00598     }
00599 }
00600 
00601 LIB_EXPORT int jack_recompute_total_latency(jack_client_t* ext_client, jack_port_t* port)
00602 {
00603     JackGlobals::CheckContext("jack_recompute_total_latency");
00604 
00605 
00606     JackClient* client = (JackClient*)ext_client;
00607     uintptr_t port_aux = (uintptr_t)port;
00608     jack_port_id_t myport = (jack_port_id_t)port_aux;
00609     if (client == NULL) {
00610         jack_error("jack_recompute_total_latency called with a NULL client");
00611         return -1;
00612     } else if (!CheckPort(myport)) {
00613         jack_error("jack_recompute_total_latency called with a NULL port");
00614         return -1;
00615     } else {
00616         WaitGraphChange();
00617         JackGraphManager* manager = GetGraphManager();
00618         return (manager ? manager->ComputeTotalLatency(myport) : -1);
00619     }
00620 }
00621 
00622 LIB_EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)
00623 {
00624     JackGlobals::CheckContext("jack_recompute_total_latencies");
00625 
00626     JackClient* client = (JackClient*)ext_client;
00627     if (client == NULL) {
00628         jack_error("jack_recompute_total_latencies called with a NULL client");
00629         return -1;
00630     } else {
00631         return client->ComputeTotalLatencies();
00632     }
00633 }
00634 
00635 LIB_EXPORT int jack_port_set_name(jack_port_t* port, const char* name)
00636 {
00637     JackGlobals::CheckContext("jack_port_set_name");
00638 
00639     uintptr_t port_aux = (uintptr_t)port;
00640     jack_port_id_t myport = (jack_port_id_t)port_aux;
00641     if (!CheckPort(myport)) {
00642         jack_error("jack_port_set_name called with an incorrect port %ld", myport);
00643         return -1;
00644     } else if (name == NULL) {
00645         jack_error("jack_port_set_name called with a NULL port name");
00646         return -1;
00647     } else {
00648         JackClient* client = NULL;
00649         for (int i = 0; i < CLIENT_NUM; i++) {
00650             // Find a valid client
00651             if ((client = JackGlobals::fClientTable[i])) {
00652                 break;
00653             }
00654         }
00655         return (client) ? client->PortRename(myport, name) : -1;
00656     }
00657 }
00658 
00659 LIB_EXPORT int jack_port_set_alias(jack_port_t* port, const char* name)
00660 {
00661     JackGlobals::CheckContext("jack_port_set_alias");
00662 
00663     uintptr_t port_aux = (uintptr_t)port;
00664     jack_port_id_t myport = (jack_port_id_t)port_aux;
00665     if (!CheckPort(myport)) {
00666         jack_error("jack_port_set_alias called with an incorrect port %ld", myport);
00667         return -1;
00668     } else if (name == NULL) {
00669         jack_error("jack_port_set_alias called with a NULL port name");
00670         return -1;
00671     } else {
00672         JackGraphManager* manager = GetGraphManager();
00673         return (manager ? manager->GetPort(myport)->SetAlias(name) : -1);
00674     }
00675 }
00676 
00677 LIB_EXPORT int jack_port_unset_alias(jack_port_t* port, const char* name)
00678 {
00679     JackGlobals::CheckContext("jack_port_unset_alias");
00680 
00681     uintptr_t port_aux = (uintptr_t)port;
00682     jack_port_id_t myport = (jack_port_id_t)port_aux;
00683     if (!CheckPort(myport)) {
00684         jack_error("jack_port_unset_alias called with an incorrect port %ld", myport);
00685         return -1;
00686     } else if (name == NULL) {
00687         jack_error("jack_port_unset_alias called with a NULL port name");
00688         return -1;
00689     } else {
00690         JackGraphManager* manager = GetGraphManager();
00691         return (manager ? manager->GetPort(myport)->UnsetAlias(name) : -1);
00692     }
00693 }
00694 
00695 LIB_EXPORT int jack_port_get_aliases(const jack_port_t* port, char* const aliases[2])
00696 {
00697     JackGlobals::CheckContext("jack_port_get_aliases");
00698 
00699     uintptr_t port_aux = (uintptr_t)port;
00700     jack_port_id_t myport = (jack_port_id_t)port_aux;
00701     if (!CheckPort(myport)) {
00702         jack_error("jack_port_get_aliases called with an incorrect port %ld", myport);
00703         return -1;
00704     } else {
00705         JackGraphManager* manager = GetGraphManager();
00706         return (manager ? manager->GetPort(myport)->GetAliases(aliases) : -1);
00707     }
00708 }
00709 
00710 LIB_EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)
00711 {
00712     JackGlobals::CheckContext("jack_port_request_monitor");
00713 
00714     uintptr_t port_aux = (uintptr_t)port;
00715     jack_port_id_t myport = (jack_port_id_t)port_aux;
00716     if (!CheckPort(myport)) {
00717         jack_error("jack_port_request_monitor called with an incorrect port %ld", myport);
00718         return -1;
00719     } else {
00720         JackGraphManager* manager = GetGraphManager();
00721         return (manager ? manager->RequestMonitor(myport, onoff) : -1);
00722     }
00723 }
00724 
00725 LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)
00726 {
00727     JackGlobals::CheckContext("jack_port_request_monitor_by_name");
00728 
00729     JackClient* client = (JackClient*)ext_client;
00730     if (client == NULL) {
00731         jack_error("jack_port_request_monitor_by_name called with a NULL client");
00732         return -1;
00733     } else {
00734         JackGraphManager* manager = GetGraphManager();
00735         if (!manager)
00736             return -1;
00737         jack_port_id_t myport = manager->GetPort(port_name);
00738         if (!CheckPort(myport)) {
00739             jack_error("jack_port_request_monitor_by_name called with an incorrect port %s", port_name);
00740             return -1;
00741         } else {
00742             return manager->RequestMonitor(myport, onoff);
00743         }
00744     }
00745 }
00746 
00747 LIB_EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)
00748 {
00749     JackGlobals::CheckContext("jack_port_ensure_monitor");
00750 
00751     uintptr_t port_aux = (uintptr_t)port;
00752     jack_port_id_t myport = (jack_port_id_t)port_aux;
00753     if (!CheckPort(myport)) {
00754         jack_error("jack_port_ensure_monitor called with an incorrect port %ld", myport);
00755         return -1;
00756     } else {
00757         JackGraphManager* manager = GetGraphManager();
00758         return (manager ? manager->GetPort(myport)->EnsureMonitor(onoff) : -1);
00759     }
00760 }
00761 
00762 LIB_EXPORT int jack_port_monitoring_input(jack_port_t* port)
00763 {
00764     JackGlobals::CheckContext("jack_port_monitoring_input");
00765 
00766     uintptr_t port_aux = (uintptr_t)port;
00767     jack_port_id_t myport = (jack_port_id_t)port_aux;
00768     if (!CheckPort(myport)) {
00769         jack_error("jack_port_monitoring_input called with an incorrect port %ld", myport);
00770         return -1;
00771     } else {
00772         JackGraphManager* manager = GetGraphManager();
00773         return (manager ? manager->GetPort(myport)->MonitoringInput() : -1);
00774     }
00775 }
00776 
00777 LIB_EXPORT int jack_is_realtime(jack_client_t* ext_client)
00778 {
00779     JackGlobals::CheckContext("jack_is_realtime");
00780 
00781     JackClient* client = (JackClient*)ext_client;
00782     if (client == NULL) {
00783         jack_error("jack_is_realtime called with a NULL client");
00784         return -1;
00785     } else {
00786         JackEngineControl* control = GetEngineControl();
00787         return (control ? control->fRealTime : -1);
00788     }
00789 }
00790 
00791 LIB_EXPORT void jack_on_shutdown(jack_client_t* ext_client, JackShutdownCallback callback, void* arg)
00792 {
00793     JackGlobals::CheckContext("jack_on_shutdown");
00794 
00795     JackClient* client = (JackClient*)ext_client;
00796     if (client == NULL) {
00797         jack_error("jack_on_shutdown called with a NULL client");
00798     } else {
00799         client->OnShutdown(callback, arg);
00800     }
00801 }
00802 
00803 LIB_EXPORT void jack_on_info_shutdown(jack_client_t* ext_client, JackInfoShutdownCallback callback, void* arg)
00804 {
00805     JackGlobals::CheckContext("jack_on_info_shutdown");
00806 
00807     JackClient* client = (JackClient*)ext_client;
00808     if (client == NULL) {
00809         jack_error("jack_on_info_shutdown called with a NULL client");
00810     } else {
00811         client->OnInfoShutdown(callback, arg);
00812     }
00813 }
00814 
00815 LIB_EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)
00816 {
00817     JackGlobals::CheckContext("jack_set_process_callback");
00818 
00819     JackClient* client = (JackClient*)ext_client;
00820     if (client == NULL) {
00821         jack_error("jack_set_process_callback called with a NULL client");
00822         return -1;
00823     } else {
00824         return client->SetProcessCallback(callback, arg);
00825     }
00826 }
00827 
00828 LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t* ext_client, int status)
00829 {
00830     JackGlobals::CheckContext("jack_thread_wait");
00831 
00832     JackClient* client = (JackClient*)ext_client;
00833     if (client == NULL) {
00834         jack_error("jack_thread_wait called with a NULL client");
00835         return 0;
00836     } else {
00837         jack_error("jack_thread_wait: deprecated, use jack_cycle_wait/jack_cycle_signal");
00838         return 0;
00839     }
00840 }
00841 
00842 LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t* ext_client)
00843 {
00844     JackGlobals::CheckContext("jack_cycle_wait");
00845 
00846     JackClient* client = (JackClient*)ext_client;
00847     if (client == NULL) {
00848         jack_error("jack_cycle_wait called with a NULL client");
00849         return 0;
00850     } else {
00851         return client->CycleWait();
00852     }
00853 }
00854 
00855 LIB_EXPORT void jack_cycle_signal(jack_client_t* ext_client, int status)
00856 {
00857     JackGlobals::CheckContext("jack_cycle_signal");
00858 
00859     JackClient* client = (JackClient*)ext_client;
00860     if (client == NULL) {
00861         jack_error("jack_cycle_signal called with a NULL client");
00862     } else {
00863         client->CycleSignal(status);
00864     }
00865 }
00866 
00867 LIB_EXPORT int jack_set_process_thread(jack_client_t* ext_client, JackThreadCallback fun, void *arg)
00868 {
00869     JackGlobals::CheckContext("jack_set_process_thread");
00870 
00871     JackClient* client = (JackClient*)ext_client;
00872     if (client == NULL) {
00873         jack_error("jack_set_process_thread called with a NULL client");
00874         return -1;
00875     } else {
00876         return client->SetProcessThread(fun, arg);
00877     }
00878 }
00879 
00880 LIB_EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)
00881 {
00882     JackGlobals::CheckContext("jack_set_freewheel_callback");
00883 
00884     JackClient* client = (JackClient*)ext_client;
00885     if (client == NULL) {
00886         jack_error("jack_set_freewheel_callback called with a NULL client");
00887         return -1;
00888     } else {
00889         return client->SetFreewheelCallback(freewheel_callback, arg);
00890     }
00891 }
00892 
00893 LIB_EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)
00894 {
00895     JackGlobals::CheckContext("jack_set_freewheel");
00896 
00897     JackClient* client = (JackClient*)ext_client;
00898     if (client == NULL) {
00899         jack_error("jack_set_freewheel called with a NULL client");
00900         return -1;
00901     } else {
00902         return client->SetFreeWheel(onoff);
00903     }
00904 }
00905 
00906 LIB_EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer_size)
00907 {
00908     JackGlobals::CheckContext("jack_set_buffer_size");
00909 
00910     JackClient* client = (JackClient*)ext_client;
00911     if (client == NULL) {
00912         jack_error("jack_set_buffer_size called with a NULL client");
00913         return -1;
00914     } else if (!CheckBufferSize(buffer_size)) {
00915         return -1;
00916     } else {
00917         return client->SetBufferSize(buffer_size);
00918     }
00919 }
00920 
00921 LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)
00922 {
00923     JackGlobals::CheckContext("jack_set_buffer_size_callback");
00924 
00925     JackClient* client = (JackClient*)ext_client;
00926     if (client == NULL) {
00927         jack_error("jack_set_buffer_size_callback called with a NULL client");
00928         return -1;
00929     } else {
00930         return client->SetBufferSizeCallback(bufsize_callback, arg);
00931     }
00932 }
00933 
00934 LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg)
00935 {
00936     JackGlobals::CheckContext("jack_set_sample_rate_callback");
00937 
00938     JackClient* client = (JackClient*)ext_client;
00939     if (client == NULL) {
00940         jack_error("jack_set_sample_rate_callback called with a NULL client");
00941         return -1;
00942     } else {
00943         return client->SetSampleRateCallback(srate_callback, arg);
00944     }
00945 }
00946 
00947 LIB_EXPORT int jack_set_client_registration_callback(jack_client_t* ext_client, JackClientRegistrationCallback registration_callback, void* arg)
00948 {
00949     JackGlobals::CheckContext("jack_set_client_registration_callback");
00950 
00951     JackClient* client = (JackClient*)ext_client;
00952     if (client == NULL) {
00953         jack_error("jack_set_client_registration_callback called with a NULL client");
00954         return -1;
00955     } else {
00956         return client->SetClientRegistrationCallback(registration_callback, arg);
00957     }
00958 }
00959 
00960 LIB_EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)
00961 {
00962     JackGlobals::CheckContext("jack_set_port_registration_callback");
00963 
00964     JackClient* client = (JackClient*)ext_client;
00965     if (client == NULL) {
00966         jack_error("jack_set_port_registration_callback called with a NULL client");
00967         return -1;
00968     } else {
00969         return client->SetPortRegistrationCallback(registration_callback, arg);
00970     }
00971 }
00972 
00973 LIB_EXPORT int jack_set_port_connect_callback(jack_client_t* ext_client, JackPortConnectCallback portconnect_callback, void* arg)
00974 {
00975     JackGlobals::CheckContext("jack_set_port_connect_callback");
00976 
00977     JackClient* client = (JackClient*)ext_client;
00978     if (client == NULL) {
00979         jack_error("jack_set_port_connect_callback called with a NULL client");
00980         return -1;
00981     } else {
00982         return client->SetPortConnectCallback(portconnect_callback, arg);
00983     }
00984 }
00985 
00986 LIB_EXPORT int jack_set_port_rename_callback(jack_client_t* ext_client, JackPortRenameCallback rename_callback, void* arg)
00987 {
00988     JackGlobals::CheckContext("jack_set_port_rename_callback");
00989 
00990     JackClient* client = (JackClient*)ext_client;
00991     if (client == NULL) {
00992         jack_error("jack_set_port_rename_callback called with a NULL client");
00993         return -1;
00994     } else {
00995         return client->SetPortRenameCallback(rename_callback, arg);
00996     }
00997 }
00998 
00999 LIB_EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)
01000 {
01001     JackGlobals::CheckContext("jack_set_graph_order_callback");
01002 
01003     JackClient* client = (JackClient*)ext_client;
01004     jack_log("jack_set_graph_order_callback ext_client %x client %x ", ext_client, client);
01005     if (client == NULL) {
01006         jack_error("jack_set_graph_order_callback called with a NULL client");
01007         return -1;
01008     } else {
01009         return client->SetGraphOrderCallback(graph_callback, arg);
01010     }
01011 }
01012 
01013 LIB_EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xrun_callback, void* arg)
01014 {
01015     JackGlobals::CheckContext("jack_set_xrun_callback");
01016 
01017     JackClient* client = (JackClient*)ext_client;
01018     if (client == NULL) {
01019         jack_error("jack_set_xrun_callback called with a NULL client");
01020         return -1;
01021     } else {
01022         return client->SetXRunCallback(xrun_callback, arg);
01023     }
01024 }
01025 
01026 LIB_EXPORT int jack_set_latency_callback(jack_client_t* ext_client, JackLatencyCallback latency_callback, void *arg)
01027 {
01028     JackGlobals::CheckContext("jack_set_latency_callback");
01029 
01030     JackClient* client = (JackClient*)ext_client;
01031     if (client == NULL) {
01032         jack_error("jack_set_latency_callback called with a NULL client");
01033         return -1;
01034     } else {
01035         return client->SetLatencyCallback(latency_callback, arg);
01036     }
01037 }
01038 
01039 LIB_EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg)
01040 {
01041     JackGlobals::CheckContext("jack_set_thread_init_callback");
01042 
01043     JackClient* client = (JackClient*)ext_client;
01044     jack_log("jack_set_thread_init_callback ext_client %x client %x ", ext_client, client);
01045     if (client == NULL) {
01046         jack_error("jack_set_thread_init_callback called with a NULL client");
01047         return -1;
01048     } else {
01049         return client->SetInitCallback(init_callback, arg);
01050     }
01051 }
01052 
01053 LIB_EXPORT int jack_activate(jack_client_t* ext_client)
01054 {
01055     JackGlobals::CheckContext("jack_activate");
01056 
01057     JackClient* client = (JackClient*)ext_client;
01058     if (client == NULL) {
01059         jack_error("jack_activate called with a NULL client");
01060         return -1;
01061     } else {
01062         return client->Activate();
01063     }
01064 }
01065 
01066 LIB_EXPORT int jack_deactivate(jack_client_t* ext_client)
01067 {
01068     JackGlobals::CheckContext("jack_deactivate");
01069 
01070     JackClient* client = (JackClient*)ext_client;
01071     if (client == NULL) {
01072         jack_error("jack_deactivate called with a NULL client");
01073         return -1;
01074     } else {
01075         return client->Deactivate();
01076     }
01077 }
01078 
01079 LIB_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)
01080 {
01081     JackGlobals::CheckContext("jack_port_register");
01082 
01083     JackClient* client = (JackClient*)ext_client;
01084     if (client == NULL) {
01085         jack_error("jack_port_register called with a NULL client");
01086         return NULL;
01087     } else if ((port_name == NULL) || (port_type == NULL)) {
01088         jack_error("jack_port_register called with a NULL port name or a NULL port_type");
01089         return NULL;
01090     } else {
01091         return (jack_port_t *)((uintptr_t)client->PortRegister(port_name, port_type, flags, buffer_size));
01092     }
01093 }
01094 
01095 LIB_EXPORT int jack_port_unregister(jack_client_t* ext_client, jack_port_t* port)
01096 {
01097     JackGlobals::CheckContext("jack_port_unregister");
01098 
01099     JackClient* client = (JackClient*)ext_client;
01100     if (client == NULL) {
01101         jack_error("jack_port_unregister called with a NULL client");
01102         return -1;
01103     }
01104     uintptr_t port_aux = (uintptr_t)port;
01105     jack_port_id_t myport = (jack_port_id_t)port_aux;
01106     if (!CheckPort(myport)) {
01107         jack_error("jack_port_unregister called with an incorrect port %ld", myport);
01108         return -1;
01109     }
01110     return client->PortUnRegister(myport);
01111 }
01112 
01113 LIB_EXPORT int jack_port_is_mine(const jack_client_t* ext_client, const jack_port_t* port)
01114 {
01115     JackGlobals::CheckContext("jack_port_is_mine");
01116 
01117     JackClient* client = (JackClient*)ext_client;
01118     if (client == NULL) {
01119         jack_error("jack_port_is_mine called with a NULL client");
01120         return -1;
01121     }
01122     uintptr_t port_aux = (uintptr_t)port;
01123     jack_port_id_t myport = (jack_port_id_t)port_aux;
01124     if (!CheckPort(myport)) {
01125         jack_error("jack_port_is_mine called with an incorrect port %ld", myport);
01126         return -1;
01127     }
01128     return client->PortIsMine(myport);
01129 }
01130 
01131 LIB_EXPORT const char** jack_port_get_connections(const jack_port_t* port)
01132 {
01133     JackGlobals::CheckContext("jack_port_get_connections");
01134 
01135     uintptr_t port_aux = (uintptr_t)port;
01136     jack_port_id_t myport = (jack_port_id_t)port_aux;
01137     if (!CheckPort(myport)) {
01138         jack_error("jack_port_get_connections called with an incorrect port %ld", myport);
01139         return NULL;
01140     } else {
01141         WaitGraphChange();
01142         JackGraphManager* manager = GetGraphManager();
01143         return (manager ? manager->GetConnections(myport) : NULL);
01144     }
01145 }
01146 
01147 // Calling client does not need to "own" the port
01148 LIB_EXPORT const char** jack_port_get_all_connections(const jack_client_t* ext_client, const jack_port_t* port)
01149 {
01150     JackGlobals::CheckContext("jack_port_get_all_connections");
01151 
01152     JackClient* client = (JackClient*)ext_client;
01153     if (client == NULL) {
01154         jack_error("jack_port_get_all_connections called with a NULL client");
01155         return NULL;
01156     }
01157 
01158     uintptr_t port_aux = (uintptr_t)port;
01159     jack_port_id_t myport = (jack_port_id_t)port_aux;
01160     if (!CheckPort(myport)) {
01161         jack_error("jack_port_get_all_connections called with an incorrect port %ld", myport);
01162         return NULL;
01163     } else {
01164         WaitGraphChange();
01165         JackGraphManager* manager = GetGraphManager();
01166         return (manager ? manager->GetConnections(myport) : NULL);
01167     }
01168 }
01169 
01170 LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t* ext_client, jack_port_t* port)
01171 {
01172     JackGlobals::CheckContext("jack_port_get_total_latency");
01173 
01174     JackClient* client = (JackClient*)ext_client;
01175     if (client == NULL) {
01176         jack_error("jack_port_get_total_latency called with a NULL client");
01177         return 0;
01178     }
01179 
01180     uintptr_t port_aux = (uintptr_t)port;
01181     jack_port_id_t myport = (jack_port_id_t)port_aux;
01182     if (!CheckPort(myport)) {
01183         jack_error("jack_port_get_total_latency called with an incorrect port %ld", myport);
01184         return 0;
01185     } else {
01186         WaitGraphChange();
01187         JackGraphManager* manager = GetGraphManager();
01188         if (manager) {
01189             manager->ComputeTotalLatency(myport);
01190             return manager->GetPort(myport)->GetTotalLatency();
01191         } else {
01192             return 0;
01193         }
01194     }
01195 }
01196 
01197 LIB_EXPORT int jack_connect(jack_client_t* ext_client, const char* src, const char* dst)
01198 {
01199     JackGlobals::CheckContext("jack_connect");
01200 
01201     JackClient* client = (JackClient*)ext_client;
01202     if (client == NULL) {
01203         jack_error("jack_connect called with a NULL client");
01204         return -1;
01205     } else if ((src == NULL) || (dst == NULL)) {
01206         jack_error("jack_connect called with a NULL port name");
01207         return -1;
01208     } else {
01209         return client->PortConnect(src, dst);
01210     }
01211 }
01212 
01213 LIB_EXPORT int jack_disconnect(jack_client_t* ext_client, const char* src, const char* dst)
01214 {
01215     JackGlobals::CheckContext("jack_disconnect");
01216 
01217     JackClient* client = (JackClient*)ext_client;
01218     if (client == NULL) {
01219         jack_error("jack_disconnect called with a NULL client");
01220         return -1;
01221     } else if ((src == NULL) || (dst == NULL)) {
01222         jack_error("jack_disconnect called with a NULL port name");
01223         return -1;
01224     } else {
01225         return client->PortDisconnect(src, dst);
01226     }
01227 }
01228 
01229 LIB_EXPORT int jack_port_disconnect(jack_client_t* ext_client, jack_port_t* src)
01230 {
01231     JackGlobals::CheckContext("jack_port_disconnect");
01232 
01233     JackClient* client = (JackClient*)ext_client;
01234     if (client == NULL) {
01235         jack_error("jack_port_disconnect called with a NULL client");
01236         return -1;
01237     }
01238     uintptr_t port_aux = (uintptr_t)src;
01239     jack_port_id_t myport = (jack_port_id_t)port_aux;
01240     if (!CheckPort(myport)) {
01241         jack_error("jack_port_disconnect called with an incorrect port %ld", myport);
01242         return -1;
01243     }
01244     return client->PortDisconnect(myport);
01245 }
01246 
01247 LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t* ext_client)
01248 {
01249     JackGlobals::CheckContext("jack_get_sample_rate");
01250 
01251     JackClient* client = (JackClient*)ext_client;
01252     if (client == NULL) {
01253         jack_error("jack_get_sample_rate called with a NULL client");
01254         return 0;
01255     } else {
01256         JackEngineControl* control = GetEngineControl();
01257         return (control ? control->fSampleRate : 0);
01258     }
01259 }
01260 
01261 LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t* ext_client)
01262 {
01263     JackGlobals::CheckContext("jack_get_buffer_size");
01264 
01265     JackClient* client = (JackClient*)ext_client;
01266     if (client == NULL) {
01267         jack_error("jack_get_buffer_size called with a NULL client");
01268         return 0;
01269     } else {
01270         JackEngineControl* control = GetEngineControl();
01271         return (control ? control->fBufferSize : 0);
01272     }
01273 }
01274 
01275 LIB_EXPORT const char** jack_get_ports(jack_client_t* ext_client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)
01276 {
01277     JackGlobals::CheckContext("jack_get_ports");
01278 
01279     JackClient* client = (JackClient*)ext_client;
01280     if (client == NULL) {
01281         jack_error("jack_get_ports called with a NULL client");
01282         return NULL;
01283     }
01284     JackGraphManager* manager = GetGraphManager();
01285     return (manager ? manager->GetPorts(port_name_pattern, type_name_pattern, flags) : NULL);
01286 }
01287 
01288 LIB_EXPORT jack_port_t* jack_port_by_name(jack_client_t* ext_client, const char* portname)
01289 {
01290     JackGlobals::CheckContext("jack_port_by_name");
01291 
01292     JackClient* client = (JackClient*)ext_client;
01293     if (client == NULL) {
01294         jack_error("jack_port_by_name called with a NULL client");
01295         return NULL;
01296     }
01297 
01298     if (portname == NULL) {
01299         jack_error("jack_port_by_name called with a NULL port name");
01300         return NULL;
01301     }
01302     
01303     JackGraphManager* manager = GetGraphManager();
01304     if (manager) {
01305         int res = manager->GetPort(portname); // returns a port index at least > 1
01306         return (res == NO_PORT) ? NULL : (jack_port_t*)((uintptr_t)res);
01307     } else {
01308         return NULL;
01309     }
01310 }
01311 
01312 LIB_EXPORT jack_port_t* jack_port_by_id(jack_client_t* ext_client, jack_port_id_t id)
01313 {
01314     JackGlobals::CheckContext("jack_port_by_id");
01315 
01316     /* jack_port_t* type is actually the port index */
01317     return (jack_port_t*)((uintptr_t)id);
01318 }
01319 
01320 LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t* ext_client)
01321 {
01322     JackGlobals::CheckContext("jack_engine_takeover_timebase");
01323 
01324     JackClient* client = (JackClient*)ext_client;
01325     if (client == NULL) {
01326         jack_error("jack_engine_takeover_timebase called with a NULL client");
01327         return -1;
01328     } else {
01329         jack_error("jack_engine_takeover_timebase: deprecated\n");
01330         return 0;
01331     }
01332 }
01333 
01334 LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* ext_client)
01335 {
01336     JackGlobals::CheckContext("jack_frames_since_cycle_start");
01337 
01338     JackTimer timer;
01339     JackEngineControl* control = GetEngineControl();
01340     if (control) {
01341         control->ReadFrameTime(&timer);
01342         return timer.FramesSinceCycleStart(GetMicroSeconds(), control->fSampleRate);
01343     } else {
01344         return 0;
01345     }
01346 }
01347 
01348 LIB_EXPORT jack_time_t jack_get_time()
01349 {
01350     JackGlobals::CheckContext("jack_get_time");
01351 
01352     return GetMicroSeconds();
01353 }
01354 
01355 LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t* ext_client, jack_nframes_t frames)
01356 {
01357     JackGlobals::CheckContext("jack_frames_to_time");
01358 
01359     JackClient* client = (JackClient*)ext_client;
01360     if (client == NULL) {
01361         jack_error("jack_frames_to_time called with a NULL client");
01362         return 0;
01363     } else {
01364         JackTimer timer;
01365         JackEngineControl* control = GetEngineControl();
01366         if (control) {
01367             control->ReadFrameTime(&timer);
01368             return timer.Frames2Time(frames, control->fBufferSize);
01369         } else {
01370             return 0;
01371         }
01372     }
01373 }
01374 
01375 LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t* ext_client, jack_time_t usecs)
01376 {
01377     JackGlobals::CheckContext("jack_time_to_frames");
01378 
01379     JackClient* client = (JackClient*)ext_client;
01380     if (client == NULL) {
01381         jack_error("jack_time_to_frames called with a NULL client");
01382         return 0;
01383     } else {
01384         JackTimer timer;
01385         JackEngineControl* control = GetEngineControl();
01386         if (control) {
01387             control->ReadFrameTime(&timer);
01388             return timer.Time2Frames(usecs, control->fBufferSize);
01389         } else {
01390             return 0;
01391         }
01392     }
01393 }
01394 
01395 LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t* ext_client)
01396 {
01397     JackGlobals::CheckContext("jack_frame_time");
01398 
01399     return jack_time_to_frames(ext_client, GetMicroSeconds());
01400 }
01401 
01402 LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t* ext_client)
01403 {
01404     JackGlobals::CheckContext("jack_last_frame_time");
01405 
01406     JackEngineControl* control = GetEngineControl();
01407     return (control) ? control->fFrameTimer.ReadCurrentState()->CurFrame() : 0;
01408 }
01409 
01410 LIB_EXPORT int jack_get_cycle_times(const jack_client_t *client,
01411                                     jack_nframes_t *current_frames,
01412                                     jack_time_t    *current_usecs,
01413                                     jack_time_t    *next_usecs,
01414                                     float          *period_usecs)
01415 {
01416     JackGlobals::CheckContext("jack_get_cycle_times");
01417 
01418     JackEngineControl* control = GetEngineControl();
01419     if (control) {
01420         JackTimer timer;
01421         control->ReadFrameTime(&timer);
01422         return timer.GetCycleTimes(current_frames, current_usecs, next_usecs, period_usecs);
01423     } else {
01424         return -1;
01425     }
01426 }
01427 
01428 LIB_EXPORT float jack_cpu_load(jack_client_t* ext_client)
01429 {
01430     JackGlobals::CheckContext("jack_cpu_load");
01431 
01432     JackClient* client = (JackClient*)ext_client;
01433     if (client == NULL) {
01434         jack_error("jack_cpu_load called with a NULL client");
01435         return 0.0f;
01436     } else {
01437         JackEngineControl* control = GetEngineControl();
01438         return (control ? control->fCPULoad : 0.0f);
01439     }
01440 }
01441 
01442 LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t* ext_client)
01443 {
01444     JackGlobals::CheckContext("jack_client_thread_id");
01445 
01446     JackClient* client = (JackClient*)ext_client;
01447     if (client == NULL) {
01448         jack_error("jack_client_thread_id called with a NULL client");
01449         return (jack_native_thread_t)NULL;
01450     } else {
01451         return client->GetThreadID();
01452     }
01453 }
01454 
01455 LIB_EXPORT char* jack_get_client_name(jack_client_t* ext_client)
01456 {
01457     JackGlobals::CheckContext("jack_get_client_name");
01458 
01459     JackClient* client = (JackClient*)ext_client;
01460     if (client == NULL) {
01461         jack_error("jack_get_client_name called with a NULL client");
01462         return NULL;
01463     } else {
01464         return client->GetClientControl()->fName;
01465     }
01466 }
01467 
01468 LIB_EXPORT int jack_client_name_size(void)
01469 {
01470     return JACK_CLIENT_NAME_SIZE;
01471 }
01472 
01473 LIB_EXPORT int jack_port_name_size(void)
01474 {
01475     return REAL_JACK_PORT_NAME_SIZE;
01476 }
01477 
01478 LIB_EXPORT int jack_port_type_size(void)
01479 {
01480     return JACK_PORT_TYPE_SIZE;
01481 }
01482 
01483 LIB_EXPORT size_t jack_port_type_get_buffer_size(jack_client_t* ext_client, const char* port_type)
01484 {
01485     JackGlobals::CheckContext("jack_port_type_get_buffer_size");
01486 
01487     JackClient* client = (JackClient*)ext_client;
01488     if (client == NULL) {
01489         jack_error("jack_port_type_get_buffer_size called with a NULL client");
01490         return 0;
01491     } else {
01492         jack_port_type_id_t port_id = GetPortTypeId(port_type);
01493         if (port_id == PORT_TYPES_MAX) {
01494             jack_error("jack_port_type_get_buffer_size called with an unknown port type = %s", port_type);
01495             return 0;
01496         } else {
01497             return GetPortType(port_id)->size();
01498         }
01499     }
01500 }
01501 
01502 // transport.h
01503 LIB_EXPORT int jack_release_timebase(jack_client_t* ext_client)
01504 {
01505     JackGlobals::CheckContext("jack_release_timebase");
01506 
01507     JackClient* client = (JackClient*)ext_client;
01508     if (client == NULL) {
01509         jack_error("jack_release_timebase called with a NULL client");
01510         return -1;
01511     } else {
01512         return client->ReleaseTimebase();
01513     }
01514 }
01515 
01516 LIB_EXPORT int jack_set_sync_callback(jack_client_t* ext_client, JackSyncCallback sync_callback, void *arg)
01517 {
01518     JackGlobals::CheckContext("jack_set_sync_callback");
01519 
01520     JackClient* client = (JackClient*)ext_client;
01521     if (client == NULL) {
01522         jack_error("jack_set_sync_callback called with a NULL client");
01523         return -1;
01524     } else {
01525         return client->SetSyncCallback(sync_callback, arg);
01526     }
01527 }
01528 
01529 LIB_EXPORT int jack_set_sync_timeout(jack_client_t* ext_client, jack_time_t timeout)
01530 {
01531     JackGlobals::CheckContext("jack_set_sync_timeout");
01532 
01533     JackClient* client = (JackClient*)ext_client;
01534     if (client == NULL) {
01535         jack_error("jack_set_sync_timeout called with a NULL client");
01536         return -1;
01537     } else {
01538         return client->SetSyncTimeout(timeout);
01539     }
01540 }
01541 
01542 LIB_EXPORT int jack_set_timebase_callback(jack_client_t* ext_client, int conditional, JackTimebaseCallback timebase_callback, void* arg)
01543 {
01544     JackGlobals::CheckContext("jack_set_timebase_callback");
01545 
01546     JackClient* client = (JackClient*)ext_client;
01547     if (client == NULL) {
01548         jack_error("jack_set_timebase_callback called with a NULL client");
01549         return -1;
01550     } else {
01551         return client->SetTimebaseCallback(conditional, timebase_callback, arg);
01552     }
01553 }
01554 
01555 LIB_EXPORT int jack_transport_locate(jack_client_t* ext_client, jack_nframes_t frame)
01556 {
01557     JackGlobals::CheckContext("jack_transport_locate");
01558 
01559     JackClient* client = (JackClient*)ext_client;
01560     if (client == NULL) {
01561         jack_error("jack_transport_locate called with a NULL client");
01562         return -1;
01563     } else {
01564         client->TransportLocate(frame);
01565         return 0;
01566     }
01567 }
01568 
01569 LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t* ext_client, jack_position_t* pos)
01570 {
01571     JackGlobals::CheckContext("jack_transport_query");
01572 
01573     JackClient* client = (JackClient*)ext_client;
01574     if (client == NULL) {
01575         jack_error("jack_transport_query called with a NULL client");
01576         return JackTransportStopped;
01577     } else {
01578         return client->TransportQuery(pos);
01579     }
01580 }
01581 
01582 LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t* ext_client)
01583 {
01584     JackGlobals::CheckContext("jack_get_current_transport_frame");
01585 
01586     JackClient* client = (JackClient*)ext_client;
01587     if (client == NULL) {
01588         jack_error("jack_get_current_transport_frame called with a NULL client");
01589         return 0;
01590     } else {
01591         return client->GetCurrentTransportFrame();
01592     }
01593 }
01594 
01595 LIB_EXPORT int jack_transport_reposition(jack_client_t* ext_client, const jack_position_t* pos)
01596 {
01597     JackGlobals::CheckContext("jack_transport_reposition");
01598 
01599     JackClient* client = (JackClient*)ext_client;
01600     if (client == NULL) {
01601         jack_error("jack_transport_reposition called with a NULL client");
01602         return -1;
01603     } else {
01604         client->TransportReposition(pos);
01605         return 0;
01606     }
01607 }
01608 
01609 LIB_EXPORT void jack_transport_start(jack_client_t* ext_client)
01610 {
01611     JackGlobals::CheckContext("jack_transport_start");
01612 
01613     JackClient* client = (JackClient*)ext_client;
01614     if (client == NULL) {
01615         jack_error("jack_transport_start called with a NULL client");
01616     } else {
01617         client->TransportStart();
01618     }
01619 }
01620 
01621 LIB_EXPORT void jack_transport_stop(jack_client_t* ext_client)
01622 {
01623     JackGlobals::CheckContext("jack_transport_stop");
01624 
01625     JackClient* client = (JackClient*)ext_client;
01626     if (client == NULL) {
01627         jack_error("jack_transport_stop called with a NULL client");
01628     } else {
01629         client->TransportStop();
01630     }
01631 }
01632 
01633 // deprecated
01634 LIB_EXPORT void jack_get_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)
01635 {
01636     JackGlobals::CheckContext("jack_get_transport_info");
01637 
01638     jack_error("jack_get_transport_info: deprecated");
01639     if (tinfo)
01640         memset(tinfo, 0, sizeof(jack_transport_info_t));
01641 }
01642 
01643 LIB_EXPORT void jack_set_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)
01644 {
01645     JackGlobals::CheckContext("jack_set_transport_info");
01646 
01647     jack_error("jack_set_transport_info: deprecated");
01648     if (tinfo)
01649         memset(tinfo, 0, sizeof(jack_transport_info_t));
01650 }
01651 
01652 // statistics.h
01653 LIB_EXPORT float jack_get_max_delayed_usecs(jack_client_t* ext_client)
01654 {
01655     JackGlobals::CheckContext("jack_get_max_delayed_usecs");
01656 
01657     JackClient* client = (JackClient*)ext_client;
01658     if (client == NULL) {
01659         jack_error("jack_get_max_delayed_usecs called with a NULL client");
01660         return 0.f;
01661     } else {
01662         JackEngineControl* control = GetEngineControl();
01663         return (control ? control->fMaxDelayedUsecs : 0.f);
01664     }
01665  }
01666 
01667 LIB_EXPORT float jack_get_xrun_delayed_usecs(jack_client_t* ext_client)
01668 {
01669     JackGlobals::CheckContext("jack_get_xrun_delayed_usecs");
01670 
01671     JackClient* client = (JackClient*)ext_client;
01672     if (client == NULL) {
01673         jack_error("jack_get_xrun_delayed_usecs called with a NULL client");
01674         return 0.f;
01675     } else {
01676         JackEngineControl* control = GetEngineControl();
01677         return (control ? control->fXrunDelayedUsecs : 0.f);
01678     }
01679 }
01680 
01681 LIB_EXPORT void jack_reset_max_delayed_usecs(jack_client_t* ext_client)
01682 {
01683     JackGlobals::CheckContext("jack_reset_max_delayed_usecs");
01684 
01685     JackClient* client = (JackClient*)ext_client;
01686     if (client == NULL) {
01687         jack_error("jack_reset_max_delayed_usecs called with a NULL client");
01688     } else {
01689         JackEngineControl* control = GetEngineControl();
01690         control->ResetXRun();
01691     }
01692 }
01693 
01694 // thread.h
01695 LIB_EXPORT int jack_client_real_time_priority(jack_client_t* ext_client)
01696 {
01697     JackGlobals::CheckContext("jack_client_real_time_priority");
01698 
01699     JackClient* client = (JackClient*)ext_client;
01700     if (client == NULL) {
01701         jack_error("jack_client_real_time_priority called with a NULL client");
01702         return -1;
01703     } else {
01704         JackEngineControl* control = GetEngineControl();
01705         return (control->fRealTime) ? control->fClientPriority : -1;
01706     }
01707 }
01708 
01709 LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t* ext_client)
01710 {
01711     JackGlobals::CheckContext("jack_client_max_real_time_priority");
01712 
01713     JackClient* client = (JackClient*)ext_client;
01714     if (client == NULL) {
01715         jack_error("jack_client_max_real_time_priority called with a NULL client");
01716         return -1;
01717     } else {
01718         JackEngineControl* control = GetEngineControl();
01719         return (control->fRealTime) ? control->fMaxClientPriority : -1;
01720     }
01721 }
01722 
01723 LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority)
01724 {
01725     JackEngineControl* control = GetEngineControl();
01726     return (control
01727         ? JackThread::AcquireRealTimeImp(thread, priority, control->fPeriod, control->fComputation, control->fConstraint)
01728         : -1);
01729 }
01730 
01731 LIB_EXPORT int jack_client_create_thread(jack_client_t* client,
01732                                      jack_native_thread_t *thread,
01733                                      int priority,
01734                                      int realtime,      /* boolean */
01735                                      thread_routine routine,
01736                                      void *arg)
01737 {
01738     JackGlobals::CheckContext("jack_client_create_thread");
01739 
01740     JackEngineControl* control = GetEngineControl();
01741     int res = JackThread::StartImp(thread, priority, realtime, routine, arg);
01742     return (res == 0)
01743         ? ((realtime ? JackThread::AcquireRealTimeImp(*thread, priority, control->fPeriod, control->fComputation, control->fConstraint) : res))
01744         : res;
01745 }
01746 
01747 LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread)
01748 {
01749     return JackThread::DropRealTimeImp(thread);
01750 }
01751 
01752 LIB_EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread)
01753 {
01754     JackGlobals::CheckContext("jack_client_stop_thread");
01755     return JackThread::StopImp(thread);
01756 }
01757 
01758 LIB_EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread)
01759 {
01760     JackGlobals::CheckContext("jack_client_kill_thread");
01761     return JackThread::KillImp(thread);
01762 }
01763 
01764 #ifndef WIN32
01765 LIB_EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc)
01766 {
01767     if (jtc == NULL) {
01768         JackGlobals::fJackThreadCreator = pthread_create;
01769         } else {
01770         JackGlobals::fJackThreadCreator = jtc;
01771         }
01772 }
01773 #endif
01774 
01775 // intclient.h
01776 LIB_EXPORT int jack_internal_client_new (const char* client_name,
01777                                      const char* load_name,
01778                                      const char* load_init)
01779 {
01780     JackGlobals::CheckContext("jack_internal_client_new");
01781     jack_error("jack_internal_client_new: deprecated");
01782     return -1;
01783 }
01784 
01785 LIB_EXPORT void jack_internal_client_close (const char* client_name)
01786 {
01787     JackGlobals::CheckContext("jack_internal_client_close");
01788     jack_error("jack_internal_client_close: deprecated");
01789 }
01790 
01791 LIB_EXPORT char* jack_get_internal_client_name(jack_client_t* ext_client, jack_intclient_t intclient)
01792 {
01793     JackGlobals::CheckContext("jack_get_internal_client_name");
01794 
01795     JackClient* client = (JackClient*)ext_client;
01796     if (client == NULL) {
01797         jack_error("jack_get_internal_client_name called with a NULL client");
01798         return NULL;
01799     } else if (intclient >= CLIENT_NUM) {
01800         jack_error("jack_get_internal_client_name: incorrect client");
01801         return NULL;
01802     } else {
01803         return client->GetInternalClientName(intclient);
01804     }
01805 }
01806 
01807 LIB_EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t* ext_client, const char* client_name, jack_status_t* status)
01808 {
01809     JackGlobals::CheckContext("jack_internal_client_handle");
01810 
01811     JackClient* client = (JackClient*)ext_client;
01812     if (client == NULL) {
01813         jack_error("jack_internal_client_handle called with a NULL client");
01814         return 0;
01815     } else {
01816         jack_status_t my_status;
01817         if (status == NULL)             /* no status from caller? */
01818             status = &my_status;        /* use local status word */
01819         *status = (jack_status_t)0;
01820         return client->InternalClientHandle(client_name, status);
01821     }
01822 }
01823 
01824 static jack_intclient_t jack_internal_client_load_aux(jack_client_t* ext_client, const char* client_name, jack_options_t options, jack_status_t* status, va_list ap)
01825 {
01826     JackGlobals::CheckContext("jack_internal_client_load_aux");
01827 
01828     JackClient* client = (JackClient*)ext_client;
01829     if (client == NULL) {
01830         jack_error("jack_internal_client_load called with a NULL client");
01831         return 0;
01832     } else {
01833         jack_varargs_t va;
01834         jack_status_t my_status;
01835 
01836         if (status == NULL)             /* no status from caller? */
01837             status = &my_status;        /* use local status word */
01838         *status = (jack_status_t)0;
01839 
01840         /* validate parameters */
01841         if ((options & ~JackLoadOptions)) {
01842             int my_status1 = *status | (JackFailure | JackInvalidOption);
01843             *status = (jack_status_t)my_status1;
01844             return 0;
01845         }
01846 
01847         /* parse variable arguments */
01848         jack_varargs_parse(options, ap, &va);
01849         return client->InternalClientLoad(client_name, options, status, &va);
01850     }
01851 }
01852 
01853 LIB_EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client, const char* client_name, jack_options_t options, jack_status_t *status, ...)
01854 {
01855     JackGlobals::CheckContext("jack_internal_client_load");
01856 
01857     va_list ap;
01858     va_start(ap, status);
01859     jack_intclient_t res = jack_internal_client_load_aux(client, client_name, options, status, ap);
01860     va_end(ap);
01861     return res;
01862 }
01863 
01864 LIB_EXPORT jack_status_t jack_internal_client_unload(jack_client_t* ext_client, jack_intclient_t intclient)
01865 {
01866     JackGlobals::CheckContext("jack_internal_client_load");
01867 
01868     JackClient* client = (JackClient*)ext_client;
01869     if (client == NULL) {
01870         jack_error("jack_internal_client_unload called with a NULL client");
01871         return (jack_status_t)(JackNoSuchClient | JackFailure);
01872     } else if (intclient >= CLIENT_NUM) {
01873         jack_error("jack_internal_client_unload: incorrect client");
01874         return (jack_status_t)(JackNoSuchClient | JackFailure);
01875     } else {
01876         jack_status_t my_status;
01877         client->InternalClientUnload(intclient, &my_status);
01878         return my_status;
01879     }
01880 }
01881 
01882 LIB_EXPORT void jack_get_version(int *major_ptr,
01883                             int *minor_ptr,
01884                             int *micro_ptr,
01885                             int *proto_ptr)
01886 {
01887     JackGlobals::CheckContext("jack_get_version");
01888 
01889     // FIXME: We need these comming from build system
01890     *major_ptr = 0;
01891     *minor_ptr = 0;
01892     *micro_ptr = 0;
01893     *proto_ptr = 0;
01894 }
01895 
01896 LIB_EXPORT const char* jack_get_version_string()
01897 {
01898     JackGlobals::CheckContext("jack_get_version_string");
01899     return VERSION;
01900 }
01901 
01902 LIB_EXPORT void jack_free(void* ptr)
01903 {
01904     JackGlobals::CheckContext("jack_free");
01905 
01906     if (ptr) {
01907         free(ptr);
01908     }
01909 }
01910 
01911 // session.h
01912 LIB_EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg)
01913 {
01914     JackGlobals::CheckContext("jack_set_session_callback");
01915 
01916     JackClient* client = (JackClient*)ext_client;
01917     jack_log("jack_set_session_callback ext_client %x client %x ", ext_client, client);
01918     if (client == NULL) {
01919         jack_error("jack_set_session_callback called with a NULL client");
01920         return -1;
01921     } else {
01922         return client->SetSessionCallback(session_callback, arg);
01923     }
01924 }
01925 
01926 LIB_EXPORT jack_session_command_t* jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char* path)
01927 {
01928     JackGlobals::CheckContext("jack_session_notify");
01929 
01930     JackClient* client = (JackClient*)ext_client;
01931     jack_log("jack_session_notify ext_client %x client %x ", ext_client, client);
01932     if (client == NULL) {
01933         jack_error("jack_session_notify called with a NULL client");
01934         return NULL;
01935     } else {
01936         return client->SessionNotify(target, ev_type, path);
01937     }
01938 }
01939 
01940 LIB_EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event)
01941 {
01942     JackGlobals::CheckContext("jack_session_reply");
01943 
01944     JackClient* client = (JackClient*)ext_client;
01945     jack_log("jack_session_reply ext_client %x client %x ", ext_client, client);
01946     if (client == NULL) {
01947         jack_error("jack_session_reply called with a NULL client");
01948         return -1;
01949     } else {
01950         return client->SessionReply(event);
01951     }
01952 }
01953 
01954 LIB_EXPORT void jack_session_event_free(jack_session_event_t* ev)
01955 {
01956     JackGlobals::CheckContext("jack_session_event_free");
01957 
01958     if (ev) {
01959         if (ev->session_dir)
01960             free((void *)ev->session_dir);
01961         if (ev->client_uuid)
01962             free((void *)ev->client_uuid);
01963         if (ev->command_line)
01964             free(ev->command_line);
01965         free(ev);
01966     }
01967 }
01968 
01969 LIB_EXPORT char *jack_client_get_uuid(jack_client_t* ext_client)
01970 {
01971     JackGlobals::CheckContext("jack_client_get_uuid");
01972 
01973     JackClient* client = (JackClient*)ext_client;
01974     if (client == NULL) {
01975         jack_error("jack_client_get_uuid called with a NULL client");
01976         return NULL;
01977     } else {
01978         char retval[16];
01979         snprintf(retval, sizeof(retval), "%d", client->GetClientControl()->fSessionID);
01980         return strdup(retval);
01981     }
01982 }
01983 
01984 LIB_EXPORT char* jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name)
01985 {
01986     JackGlobals::CheckContext("jack_get_uuid_for_client_name");
01987 
01988     JackClient* client = (JackClient*)ext_client;
01989     jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);
01990     if (client == NULL) {
01991         jack_error("jack_get_uuid_for_client_name called with a NULL client");
01992         return NULL;
01993     } else {
01994         return client->GetUUIDForClientName(client_name);
01995     }
01996 }
01997 
01998 LIB_EXPORT char* jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid)
01999 {
02000     JackGlobals::CheckContext("jack_get_client_name_by_uuid");
02001 
02002     JackClient* client = (JackClient*)ext_client;
02003     jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);
02004     if (client == NULL) {
02005         jack_error("jack_get_client_name_by_uuid called with a NULL client");
02006         return NULL;
02007     } else {
02008         return client->GetClientNameByUUID(client_uuid);
02009     }
02010 }
02011 
02012 LIB_EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* client_name, const char* uuid)
02013 {
02014     JackGlobals::CheckContext("jack_reserve_client_name");
02015 
02016     JackClient* client = (JackClient*)ext_client;
02017     jack_log("jack_reserve_client_name ext_client %x client %x ", ext_client, client);
02018     if (client == NULL) {
02019         jack_error("jack_reserve_client_name called with a NULL client");
02020         return -1;
02021     } else {
02022         return client->ReserveClientName(client_name, uuid);
02023     }
02024 }
02025 
02026 LIB_EXPORT void jack_session_commands_free(jack_session_command_t *cmds)
02027 {
02028     JackGlobals::CheckContext("jack_session_commands_free");
02029 
02030 
02031     if (!cmds) {
02032         return;
02033     }
02034 
02035     int i = 0;
02036     while (1) {
02037         if (cmds[i].client_name) {
02038             free ((char *)cmds[i].client_name);
02039         }
02040         if (cmds[i].command) {
02041             free ((char *)cmds[i].command);
02042         }
02043         if (cmds[i].uuid) {
02044             free ((char *)cmds[i].uuid);
02045         } else {
02046             break;
02047         }
02048 
02049         i += 1;
02050     }
02051 
02052     free(cmds);
02053 }
02054 
02055 LIB_EXPORT int jack_client_has_session_callback(jack_client_t* ext_client, const char* client_name)
02056 {
02057     JackGlobals::CheckContext("jack_client_has_session_callback");
02058 
02059     JackClient* client = (JackClient*)ext_client;
02060     jack_log("jack_client_has_session_callback ext_client %x client %x ", ext_client, client);
02061     if (client == NULL) {
02062         jack_error("jack_client_has_session_callback called with a NULL client");
02063         return -1;
02064     } else {
02065         return client->ClientHasSessionCallback(client_name);
02066     }
02067 }
02068 
02069 LIB_EXPORT int jack_set_property(jack_client_t*, jack_uuid_t, const char*, const char*, const char*)
02070 {
02071     return -1;
02072 }
02073 
02074 LIB_EXPORT int jack_get_property(jack_uuid_t, const char*, char**, char**)
02075 {
02076     return -1;
02077 }
02078 
02079 LIB_EXPORT void jack_free_description(jack_description_t*, int)
02080 {
02081 }
02082 
02083 LIB_EXPORT int jack_get_properties(jack_uuid_t, jack_description_t*)
02084 {
02085     return -1;
02086 }
02087 
02088 LIB_EXPORT int jack_get_all_properties(jack_description_t**)
02089 {
02090     return -1;
02091 }
02092 
02093 LIB_EXPORT int jack_remove_property(jack_client_t*, jack_uuid_t, const char*)
02094 {
02095     return -1;
02096 }
02097 
02098 LIB_EXPORT int jack_remove_properties(jack_client_t*, jack_uuid_t)
02099 {
02100     return -1;
02101 }
02102 
02103 LIB_EXPORT int jack_remove_all_properties(jack_client_t*)
02104 {
02105     return -1;
02106 }
02107 
02108 LIB_EXPORT int jack_set_property_change_callback(jack_client_t*, JackPropertyChangeCallback, void*)
02109 {
02110     return -1;
02111 }
02112 
02113 LIB_EXPORT jack_uuid_t jack_client_uuid_generate()
02114 {
02115     return 0;
02116 }
02117 
02118 LIB_EXPORT jack_uuid_t jack_port_uuid_generate(uint32_t)
02119 {
02120     return 0;
02121 }
02122 
02123 LIB_EXPORT uint32_t jack_uuid_to_index(jack_uuid_t)
02124 {
02125     return 0;
02126 }
02127 
02128 LIB_EXPORT int jack_uuid_compare(jack_uuid_t, jack_uuid_t)
02129 {
02130     return 0;
02131 }
02132 
02133 LIB_EXPORT void jack_uuid_copy(jack_uuid_t*, jack_uuid_t)
02134 {
02135 }
02136 
02137 LIB_EXPORT void jack_uuid_clear(jack_uuid_t*)
02138 {
02139 }
02140 
02141 LIB_EXPORT int jack_uuid_parse(const char*, jack_uuid_t*)
02142 {
02143     return 0;
02144 }
02145 
02146 LIB_EXPORT void jack_uuid_unparse(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE])
02147 {
02148 }
02149 
02150 LIB_EXPORT int jack_uuid_empty(jack_uuid_t)
02151 {
02152     return 0;
02153 }