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