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