00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
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
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
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,
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
00287
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
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
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);
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
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
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
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
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
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,
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
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)
01857 status = &my_status;
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)
01877 status = &my_status;
01878 *status = (jack_status_t)0;
01879
01880
01881 if ((options & ~JackLoadOptions)) {
01882 int my_status1 = *status | (JackFailure | JackInvalidOption);
01883 *status = (jack_status_t)my_status1;
01884 return 0;
01885 }
01886
01887
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
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
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 }