jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2614 Commits
8 Branches
67MB
Tree: 022e551350
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '022e551350'
${ noResults }
jack2/common/JackAPI.cpp

2129 lines
73KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001-2003 Paul Davis

  3. Copyright (C) 2004-2008 Grame

  4. 

  5. This program is free software; you can redistribute it and/or modify

  6. it under the terms of the GNU Lesser General Public License as published by

  7. the Free Software Foundation; either version 2.1 of the License, or

  8. (at your option) any later version.

  9. 

  10. This program is distributed in the hope that it will be useful,

  11. but WITHOUT ANY WARRANTY; without even the implied warranty of

  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13. GNU Lesser General Public License for more details.

  14. 

  15. You should have received a copy of the GNU Lesser General Public License

  16. along with this program; if not, write to the Free Software

  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  18. 

  19. */

  20. 

  21. #include "JackClient.h"

  22. #include "JackError.h"

  23. #include "JackGraphManager.h"

  24. #include "JackEngineControl.h"

  25. #include "JackClientControl.h"

  26. #include "JackGlobals.h"

  27. #include "JackTime.h"

  28. #include "JackCompilerDeps.h"

  29. #include "JackPortType.h"

  30. #include "JackPlatformPlug.h"

  31. #include <math.h>

  32. 

  33. #ifdef __CLIENTDEBUG__

  34. #include "JackLibGlobals.h"

  35. #endif

  36. 

  37. using namespace Jack;

  38. 

  39. #ifdef __cplusplus

  40. extern "C"

  41. {

  42. #endif

  43. 

  44.     typedef void (*print_function)(const char*);

  45.     typedef void *(*thread_routine)(void*);

  46. 

  47.     LIB_EXPORT

  48.     void

  49.     jack_get_version(

  50.         int *major_ptr,

  51.         int *minor_ptr,

  52.         int *micro_ptr,

  53.         int *proto_ptr);

  54. 

  55.     LIB_EXPORT

  56.     const char*

  57.     jack_get_version_string();

  58. 

  59.     jack_client_t * jack_client_new_aux(const char* client_name,

  60.             jack_options_t options,

  61.             jack_status_t *status);

  62.     LIB_EXPORT jack_client_t * jack_client_open(const char* client_name,

  63.             jack_options_t options,

  64.             jack_status_t *status, ...);

  65.     LIB_EXPORT jack_client_t * jack_client_new(const char* client_name);

  66.     LIB_EXPORT int jack_client_name_size(void);

  67.     LIB_EXPORT char* jack_get_client_name(jack_client_t *client);

  68.     LIB_EXPORT int jack_internal_client_new(const char* client_name,

  69.                                          const char* load_name,

  70.                                          const char* load_init);

  71.     LIB_EXPORT void jack_internal_client_close(const char* client_name);

  72.     LIB_EXPORT int jack_is_realtime(jack_client_t *client);

  73.     LIB_EXPORT void jack_on_shutdown(jack_client_t *client,

  74.                                   JackShutdownCallback shutdown_callback, void *arg);

  75.     LIB_EXPORT void jack_on_info_shutdown(jack_client_t *client,

  76.                                   JackInfoShutdownCallback shutdown_callback, void *arg);

  77.     LIB_EXPORT int jack_set_process_callback(jack_client_t *client,

  78.                                           JackProcessCallback process_callback,

  79.                                           void *arg);

  80.     LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t *client, int status);

  81. 

  82.     // new

  83.     LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t*);

  84.     LIB_EXPORT void jack_cycle_signal(jack_client_t*, int status);

  85.     LIB_EXPORT int jack_set_process_thread(jack_client_t* client, JackThreadCallback fun, void *arg);

  86. 

  87.     LIB_EXPORT int jack_set_thread_init_callback(jack_client_t *client,

  88.             JackThreadInitCallback thread_init_callback,

  89.             void *arg);

  90.     LIB_EXPORT int jack_set_freewheel_callback(jack_client_t *client,

  91.                                             JackFreewheelCallback freewheel_callback,

  92.                                             void *arg);

  93.     LIB_EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);

  94.     LIB_EXPORT int jack_set_buffer_size(jack_client_t *client, jack_nframes_t nframes);

  95.     LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t *client,

  96.             JackBufferSizeCallback bufsize_callback,

  97.             void *arg);

  98.     LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t *client,

  99.             JackSampleRateCallback srate_callback,

  100.             void *arg);

  101.     LIB_EXPORT int jack_set_client_registration_callback(jack_client_t *,

  102.             JackClientRegistrationCallback

  103.             registration_callback, void *arg);

  104.     LIB_EXPORT int jack_set_port_registration_callback(jack_client_t *,

  105.             JackPortRegistrationCallback

  106.             registration_callback, void *arg);

  107.     LIB_EXPORT int jack_set_port_connect_callback(jack_client_t *,

  108.             JackPortConnectCallback

  109.             connect_callback, void *arg);

  110.     LIB_EXPORT int jack_set_port_rename_callback(jack_client_t *,

  111.                                     JackPortRenameCallback

  112.                                     rename_callback, void *arg);

  113.     LIB_EXPORT int jack_set_graph_order_callback(jack_client_t *,

  114.             JackGraphOrderCallback graph_callback,

  115.             void *);

  116.     LIB_EXPORT int jack_set_xrun_callback(jack_client_t *,

  117.                                        JackXRunCallback xrun_callback, void *arg);

  118.     LIB_EXPORT int jack_set_latency_callback(jack_client_t *client,

  119. 			       JackLatencyCallback latency_callback, void *arg);

  120. 

  121.     LIB_EXPORT int jack_activate(jack_client_t *client);

  122.     LIB_EXPORT int jack_deactivate(jack_client_t *client);

  123.     LIB_EXPORT jack_port_t * jack_port_register(jack_client_t *client,

  124.             const char* port_name,

  125.             const char* port_type,

  126.             unsigned long flags,

  127.             unsigned long buffer_size);

  128.     LIB_EXPORT int jack_port_unregister(jack_client_t *, jack_port_t *);

  129.     LIB_EXPORT void * jack_port_get_buffer(jack_port_t *, jack_nframes_t);

  130.     LIB_EXPORT const char*  jack_port_name(const jack_port_t *port);

  131.     LIB_EXPORT const char*  jack_port_short_name(const jack_port_t *port);

  132.     LIB_EXPORT int jack_port_flags(const jack_port_t *port);

  133.     LIB_EXPORT const char*  jack_port_type(const jack_port_t *port);

  134.     LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port);

  135.     LIB_EXPORT int jack_port_is_mine(const jack_client_t *, const jack_port_t *port);

  136.     LIB_EXPORT int jack_port_connected(const jack_port_t *port);

  137.     LIB_EXPORT int jack_port_connected_to(const jack_port_t *port,

  138.                                        const char* port_name);

  139.     LIB_EXPORT const char* * jack_port_get_connections(const jack_port_t *port);

  140.     LIB_EXPORT const char* * jack_port_get_all_connections(const jack_client_t *client,

  141.             const jack_port_t *port);

  142.     LIB_EXPORT int jack_port_tie(jack_port_t *src, jack_port_t *dst);

  143.     LIB_EXPORT int jack_port_untie(jack_port_t *port);

  144. 

  145.     // Old latency API

  146.     LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t *port);

  147.     LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t *,

  148.             jack_port_t *port);

  149.     LIB_EXPORT void jack_port_set_latency(jack_port_t *, jack_nframes_t);

  150.     LIB_EXPORT int jack_recompute_total_latency(jack_client_t*, jack_port_t* port);

  151. 

  152.     // New latency API

  153.     LIB_EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);

  154.     LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);

  155.     LIB_EXPORT int jack_recompute_total_latencies(jack_client_t*);

  156. 

  157.     LIB_EXPORT int jack_port_set_name(jack_port_t *port, const char* port_name);

  158.     LIB_EXPORT int jack_port_set_alias(jack_port_t *port, const char* alias);

  159.     LIB_EXPORT int jack_port_unset_alias(jack_port_t *port, const char* alias);

  160.     LIB_EXPORT int jack_port_get_aliases(const jack_port_t *port, char* const aliases[2]);

  161.     LIB_EXPORT int jack_port_request_monitor(jack_port_t *port, int onoff);

  162.     LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t *client,

  163.             const char* port_name, int onoff);

  164.     LIB_EXPORT int jack_port_ensure_monitor(jack_port_t *port, int onoff);

  165.     LIB_EXPORT int jack_port_monitoring_input(jack_port_t *port);

  166.     LIB_EXPORT int jack_connect(jack_client_t *,

  167.                              const char* source_port,

  168.                              const char* destination_port);

  169.     LIB_EXPORT int jack_disconnect(jack_client_t *,

  170.                                 const char* source_port,

  171.                                 const char* destination_port);

  172.     LIB_EXPORT int jack_port_disconnect(jack_client_t *, jack_port_t *);

  173.     LIB_EXPORT int jack_port_name_size(void);

  174.     LIB_EXPORT int jack_port_type_size(void);

  175.     LIB_EXPORT size_t jack_port_type_get_buffer_size(jack_client_t *client, const char* port_type);

  176.     LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t *);

  177.     LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t *);

  178.     LIB_EXPORT const char* * jack_get_ports(jack_client_t *,

  179.                                          const char* port_name_pattern,

  180.                                          const char* type_name_pattern,

  181.                                          unsigned long flags);

  182.     LIB_EXPORT jack_port_t * jack_port_by_name(jack_client_t *, const char* port_name);

  183.     LIB_EXPORT jack_port_t * jack_port_by_id(jack_client_t *client,

  184.                                           jack_port_id_t port_id);

  185.     LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t *);

  186.     LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t *);

  187.     LIB_EXPORT jack_time_t jack_get_time();

  188.     LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t time);

  189.     LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames);

  190.     LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t *);

  191.     LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t *client);

  192.     LIB_EXPORT float jack_cpu_load(jack_client_t *client);

  193.     LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t *);

  194.     LIB_EXPORT void jack_set_error_function(print_function);

  195.     LIB_EXPORT void jack_set_info_function(print_function);

  196. 

  197.     LIB_EXPORT float jack_get_max_delayed_usecs(jack_client_t *client);

  198.     LIB_EXPORT float jack_get_xrun_delayed_usecs(jack_client_t *client);

  199.     LIB_EXPORT void jack_reset_max_delayed_usecs(jack_client_t *client);

  200. 

  201.     LIB_EXPORT int jack_release_timebase(jack_client_t *client);

  202.     LIB_EXPORT int jack_set_sync_callback(jack_client_t *client,

  203.                                        JackSyncCallback sync_callback,

  204.                                        void *arg);

  205.     LIB_EXPORT int jack_set_sync_timeout(jack_client_t *client,

  206.                                       jack_time_t timeout);

  207.     LIB_EXPORT int jack_set_timebase_callback(jack_client_t *client,

  208.                                            int conditional,

  209.                                            JackTimebaseCallback timebase_callback,

  210.                                            void *arg);

  211.     LIB_EXPORT int jack_transport_locate(jack_client_t *client,

  212.                                       jack_nframes_t frame);

  213.     LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t *client,

  214.             jack_position_t *pos);

  215.     LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t *client);

  216.     LIB_EXPORT int jack_transport_reposition(jack_client_t *client,

  217.                                           const jack_position_t *pos);

  218.     LIB_EXPORT void jack_transport_start(jack_client_t *client);

  219.     LIB_EXPORT void jack_transport_stop(jack_client_t *client);

  220.     LIB_EXPORT void jack_get_transport_info(jack_client_t *client,

  221.                                          jack_transport_info_t *tinfo);

  222.     LIB_EXPORT void jack_set_transport_info(jack_client_t *client,

  223.                                          jack_transport_info_t *tinfo);

  224. 

  225.     LIB_EXPORT int jack_client_real_time_priority(jack_client_t*);

  226.     LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t*);

  227.     LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority);

  228.     LIB_EXPORT int jack_client_create_thread(jack_client_t* client,

  229.                                           jack_native_thread_t *thread,

  230.                                           int priority,

  231.                                           int realtime,         // boolean

  232.                                           thread_routine routine,

  233.                                           void *arg);

  234.     LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread);

  235. 

  236.     LIB_EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread);

  237.     LIB_EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread);

  238. #ifndef WIN32

  239.     LIB_EXPORT void jack_set_thread_creator(jack_thread_creator_t jtc);

  240. #endif

  241.     LIB_EXPORT char * jack_get_internal_client_name(jack_client_t *client,

  242.             jack_intclient_t intclient);

  243.     LIB_EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t *client,

  244.             const char* client_name,

  245.             jack_status_t *status);

  246.     LIB_EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client,

  247.             const char* client_name,

  248.             jack_options_t options,

  249.             jack_status_t *status, ...);

  250.     LIB_EXPORT jack_intclient_t jack_internal_client_load_aux(jack_client_t *client,

  251.             const char* client_name,

  252.             jack_options_t options,

  253.             jack_status_t *status, va_list ap);

  254. 

  255.     LIB_EXPORT jack_status_t jack_internal_client_unload(jack_client_t *client,

  256.             jack_intclient_t intclient);

  257.     LIB_EXPORT void jack_free(void* ptr);

  258. 

  259.     LIB_EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg);

  260.     LIB_EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char* path);

  261.     LIB_EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event);

  262.     LIB_EXPORT void jack_session_event_free(jack_session_event_t* ev);

  263.     LIB_EXPORT char* jack_client_get_uuid (jack_client_t *client);

  264.     LIB_EXPORT char* jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name);

  265.     LIB_EXPORT char* jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid);

  266.     LIB_EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* name, const char* uuid);

  267.     LIB_EXPORT void jack_session_commands_free(jack_session_command_t *cmds);

  268.     LIB_EXPORT int jack_client_has_session_callback(jack_client_t *client, const char* client_name);

  269. 

  270. #ifdef __cplusplus

  271. }

  272. #endif

  273. 

  274. static inline bool CheckPort(jack_port_id_t port_index)

  275. {

  276.     return (port_index > 0 && port_index < PORT_NUM_MAX);

  277. }

  278. 

  279. static inline bool CheckBufferSize(jack_nframes_t buffer_size)

  280. {

  281.     return (buffer_size >= 1 && buffer_size <= BUFFER_SIZE_MAX);

  282. }

  283. 

  284. static inline void WaitGraphChange()

  285. {

  286.     /*

  287.     TLS key that is set only in RT thread, so never waits for pending

  288.     graph change in RT context (just read the current graph state).

  289.     */

  290. 

  291.     if (jack_tls_get(JackGlobals::fRealTime) == NULL) {

  292.         JackGraphManager* manager = GetGraphManager();

  293.         JackEngineControl* control = GetEngineControl();

  294.         assert(manager);

  295.         assert(control);

  296.         if (manager->IsPendingChange()) {

  297.             jack_log("WaitGraphChange...");

  298.             JackSleep(int(control->fPeriodUsecs * 1.1f));

  299.         }

  300.     }

  301. }

  302. 

  303. LIB_EXPORT void jack_set_error_function(print_function func)

  304. {

  305.     jack_error_callback = (func == NULL) ? &default_jack_error_callback : func;

  306. }

  307. 

  308. LIB_EXPORT void jack_set_info_function(print_function func)

  309. {

  310.     jack_info_callback = (func == NULL) ? &default_jack_info_callback : func;

  311. }

  312. 

  313. LIB_EXPORT jack_client_t* jack_client_new(const char* client_name)

  314. {

  315. #ifdef __CLIENTDEBUG__

  316.     JackGlobals::CheckContext("jack_client_new");

  317. #endif

  318.     try {

  319.         assert(JackGlobals::fOpenMutex);

  320.         JackGlobals::fOpenMutex->Lock();

  321.         jack_error("jack_client_new: deprecated");

  322.         int options = JackUseExactName;

  323.         if (getenv("JACK_START_SERVER") == NULL)

  324.             options |= JackNoStartServer;

  325.         jack_client_t* res = jack_client_new_aux(client_name, (jack_options_t)options, NULL);

  326.         JackGlobals::fOpenMutex->Unlock();

  327.         return res;

  328.     } catch (std::bad_alloc& e) {

  329.         jack_error("Memory allocation error...");

  330.         return NULL;

  331.     } catch (...) {

  332.         jack_error("Unknown error...");

  333.         return NULL;

  334.     }

  335. }

  336. 

  337. LIB_EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)

  338. {

  339. #ifdef __CLIENTDEBUG__

  340.     JackGlobals::CheckContext("jack_port_get_buffer");

  341. #endif

  342.     uintptr_t port_aux = (uintptr_t)port;

  343.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  344.     if (!CheckPort(myport)) {

  345.         jack_error("jack_port_get_buffer called with an incorrect port %ld", myport);

  346.         return NULL;

  347.     } else {

  348.         JackGraphManager* manager = GetGraphManager();

  349.         return (manager ? manager->GetBuffer(myport, frames) : NULL);

  350.     }

  351. }

  352. 

  353. LIB_EXPORT const char* jack_port_name(const jack_port_t* port)

  354. {

  355. #ifdef __CLIENTDEBUG__

  356.     JackGlobals::CheckContext("jack_port_name");

  357. #endif

  358.     uintptr_t port_aux = (uintptr_t)port;

  359.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  360.     if (!CheckPort(myport)) {

  361.         jack_error("jack_port_name called with an incorrect port %ld", myport);

  362.         return NULL;

  363.     } else {

  364.         JackGraphManager* manager = GetGraphManager();

  365.         return (manager ? manager->GetPort(myport)->GetName() : NULL);

  366.     }

  367. }

  368. 

  369. LIB_EXPORT const char* jack_port_short_name(const jack_port_t* port)

  370. {

  371. #ifdef __CLIENTDEBUG__

  372.     JackGlobals::CheckContext("jack_port_short_name");

  373. #endif

  374.     uintptr_t port_aux = (uintptr_t)port;

  375.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  376.     if (!CheckPort(myport)) {

  377.         jack_error("jack_port_short_name called with an incorrect port %ld", myport);

  378.         return NULL;

  379.     } else {

  380.         JackGraphManager* manager = GetGraphManager();

  381.         return (manager ? manager->GetPort(myport)->GetShortName() : NULL);

  382.     }

  383. }

  384. 

  385. LIB_EXPORT int jack_port_flags(const jack_port_t* port)

  386. {

  387. #ifdef __CLIENTDEBUG__

  388.     JackGlobals::CheckContext("jack_port_flags");

  389. #endif

  390.     uintptr_t port_aux = (uintptr_t)port;

  391.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  392.     if (!CheckPort(myport)) {

  393.         jack_error("jack_port_flags called with an incorrect port %ld", myport);

  394.         return -1;

  395.     } else {

  396.         JackGraphManager* manager = GetGraphManager();

  397.         return (manager ? manager->GetPort(myport)->GetFlags() : -1);

  398.     }

  399. }

  400. 

  401. LIB_EXPORT const char* jack_port_type(const jack_port_t* port)

  402. {

  403. #ifdef __CLIENTDEBUG__

  404.     JackGlobals::CheckContext("jack_port_type");

  405. #endif

  406.     uintptr_t port_aux = (uintptr_t)port;

  407.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  408.    if (!CheckPort(myport)) {

  409.         jack_error("jack_port_flags called an incorrect port %ld", myport);

  410.         return NULL;

  411.     } else {

  412.         JackGraphManager* manager = GetGraphManager();

  413.         return (manager ? manager->GetPort(myport)->GetType() : NULL);

  414.     }

  415. }

  416. 

  417. LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port)

  418. {

  419. #ifdef __CLIENTDEBUG__

  420.     JackGlobals::CheckContext("jack_port_type_id");

  421. #endif

  422.     uintptr_t port_aux = (uintptr_t)port;

  423.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  424.     if (!CheckPort(myport)) {

  425.         jack_error("jack_port_type_id called an incorrect port %ld", myport);

  426.         return 0;

  427.     } else {

  428.         JackGraphManager* manager = GetGraphManager();

  429.         return (manager ? GetPortTypeId(manager->GetPort(myport)->GetType()) : 0);

  430.     }

  431. }

  432. 

  433. LIB_EXPORT int jack_port_connected(const jack_port_t* port)

  434. {

  435. #ifdef __CLIENTDEBUG__

  436.     JackGlobals::CheckContext("jack_port_connected");

  437. #endif

  438.     uintptr_t port_aux = (uintptr_t)port;

  439.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  440.     if (!CheckPort(myport)) {

  441.         jack_error("jack_port_connected called with an incorrect port %ld", myport);

  442.         return -1;

  443.     } else {

  444.         WaitGraphChange();

  445.         JackGraphManager* manager = GetGraphManager();

  446.         return (manager ? manager->GetConnectionsNum(myport) : -1);

  447.     }

  448. }

  449. 

  450. LIB_EXPORT int jack_port_connected_to(const jack_port_t* port, const char* port_name)

  451. {

  452. #ifdef __CLIENTDEBUG__

  453.     JackGlobals::CheckContext("jack_port_connected_to");

  454. #endif

  455.     uintptr_t port_aux = (uintptr_t)port;

  456.     jack_port_id_t src = (jack_port_id_t)port_aux;

  457.     if (!CheckPort(src)) {

  458.         jack_error("jack_port_connected_to called with an incorrect port %ld", src);

  459.         return -1;

  460.     } else if (port_name == NULL) {

  461.         jack_error("jack_port_connected_to called with a NULL port name");

  462.         return -1;

  463.     } else {

  464.         WaitGraphChange();

  465.         JackGraphManager* manager = GetGraphManager();

  466.         jack_port_id_t dst = (manager ? manager->GetPort(port_name) : NO_PORT);

  467.         if (dst == NO_PORT) {

  468.             jack_error("Unknown destination port port_name = %s", port_name);

  469.             return 0;

  470.         } else {

  471.             return manager->IsConnected(src, dst);

  472.         }

  473.     }

  474. }

  475. 

  476. LIB_EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)

  477. {

  478. #ifdef __CLIENTDEBUG__

  479.     JackGlobals::CheckContext("jack_port_tie");

  480. #endif

  481.     uintptr_t src_aux = (uintptr_t)src;

  482.     jack_port_id_t mysrc = (jack_port_id_t)src_aux;

  483.     if (!CheckPort(mysrc)) {

  484.         jack_error("jack_port_tie called with a NULL src port");

  485.         return -1;

  486.     }

  487.     uintptr_t dst_aux = (uintptr_t)dst;

  488.     jack_port_id_t mydst = (jack_port_id_t)dst_aux;

  489.     if (!CheckPort(mydst)) {

  490.         jack_error("jack_port_tie called with a NULL dst port");

  491.         return -1;

  492.     }

  493.     JackGraphManager* manager = GetGraphManager();

  494.     if (manager && manager->GetPort(mysrc)->GetRefNum() != manager->GetPort(mydst)->GetRefNum()) {

  495.         jack_error("jack_port_tie called with ports not belonging to the same client");

  496.         return -1;

  497.     } else {

  498.         return manager->GetPort(mydst)->Tie(mysrc);

  499.     }

  500. }

  501. 

  502. LIB_EXPORT int jack_port_untie(jack_port_t* port)

  503. {

  504. #ifdef __CLIENTDEBUG__

  505.     JackGlobals::CheckContext("jack_port_untie");

  506. #endif

  507.     uintptr_t port_aux = (uintptr_t)port;

  508.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  509.     if (!CheckPort(myport)) {

  510.         jack_error("jack_port_untie called with an incorrect port %ld", myport);

  511.         return -1;

  512.     } else {

  513.         JackGraphManager* manager = GetGraphManager();

  514.         return (manager ? manager->GetPort(myport)->UnTie() : -1);

  515.     }

  516. }

  517. 

  518. LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)

  519. {

  520. #ifdef __CLIENTDEBUG__

  521.     JackGlobals::CheckContext("jack_port_get_latency");

  522. #endif

  523.     uintptr_t port_aux = (uintptr_t)port;

  524.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  525.     if (!CheckPort(myport)) {

  526.         jack_error("jack_port_get_latency called with an incorrect port %ld", myport);

  527.         return 0;

  528.     } else {

  529.         WaitGraphChange();

  530.         JackGraphManager* manager = GetGraphManager();

  531.         return (manager ? manager->GetPort(myport)->GetLatency() : 0);

  532.     }

  533. }

  534. 

  535. LIB_EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)

  536. {

  537. #ifdef __CLIENTDEBUG__

  538.     JackGlobals::CheckContext("jack_port_set_latency");

  539. #endif

  540.     uintptr_t port_aux = (uintptr_t)port;

  541.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  542.     if (!CheckPort(myport)) {

  543.         jack_error("jack_port_set_latency called with an incorrect port %ld", myport);

  544.     } else {

  545.         JackGraphManager* manager = GetGraphManager();

  546.         if (manager)

  547.             manager->GetPort(myport)->SetLatency(frames);

  548.     }

  549. }

  550. 

  551. LIB_EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)

  552. {

  553. #ifdef __CLIENTDEBUG__

  554.     JackGlobals::CheckContext("jack_port_get_latency_range");

  555. #endif

  556.     uintptr_t port_aux = (uintptr_t)port;

  557.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  558.     if (!CheckPort(myport)) {

  559.         jack_error("jack_port_get_latency_range called with an incorrect port %ld", myport);

  560.     } else {

  561.         WaitGraphChange();

  562.         JackGraphManager* manager = GetGraphManager();

  563.         if (manager)

  564.             manager->GetPort(myport)->GetLatencyRange(mode, range);

  565.     }

  566. }

  567. 

  568. LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)

  569. {

  570. #ifdef __CLIENTDEBUG__

  571.     JackGlobals::CheckContext("jack_port_set_latency_range");

  572. #endif

  573.     uintptr_t port_aux = (uintptr_t)port;

  574.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  575.     if (!CheckPort(myport)) {

  576.         jack_error("jack_port_set_latency_range called with an incorrect port %ld", myport);

  577.     } else {

  578.         WaitGraphChange();

  579.         JackGraphManager* manager = GetGraphManager();

  580.         if (manager)

  581.             manager->GetPort(myport)->SetLatencyRange(mode, range);

  582.     }

  583. }

  584. 

  585. LIB_EXPORT int jack_recompute_total_latency(jack_client_t* ext_client, jack_port_t* port)

  586. {

  587. #ifdef __CLIENTDEBUG__

  588.     JackGlobals::CheckContext("jack_recompute_total_latency");

  589. #endif

  590. 

  591.     JackClient* client = (JackClient*)ext_client;

  592.     uintptr_t port_aux = (uintptr_t)port;

  593.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  594.     if (client == NULL) {

  595.         jack_error("jack_recompute_total_latency called with a NULL client");

  596.         return -1;

  597.     } else if (!CheckPort(myport)) {

  598.         jack_error("jack_recompute_total_latency called with a NULL port");

  599.         return -1;

  600.     } else {

  601.         WaitGraphChange();

  602.         JackGraphManager* manager = GetGraphManager();

  603.         return (manager ? manager->ComputeTotalLatency(myport) : -1);

  604.     }

  605. }

  606. 

  607. LIB_EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)

  608. {

  609. #ifdef __CLIENTDEBUG__

  610.     JackGlobals::CheckContext("jack_recompute_total_latencies");

  611. #endif

  612. 

  613.     JackClient* client = (JackClient*)ext_client;

  614.     if (client == NULL) {

  615.         jack_error("jack_recompute_total_latencies called with a NULL client");

  616.         return -1;

  617.     } else {

  618.         return client->ComputeTotalLatencies();

  619.     }

  620. }

  621. 

  622. LIB_EXPORT int jack_port_set_name(jack_port_t* port, const char* name)

  623. {

  624. #ifdef __CLIENTDEBUG__

  625.     JackGlobals::CheckContext("jack_port_set_name");

  626. #endif

  627.     uintptr_t port_aux = (uintptr_t)port;

  628.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  629.     if (!CheckPort(myport)) {

  630.         jack_error("jack_port_set_name called with an incorrect port %ld", myport);

  631.         return -1;

  632.     } else if (name == NULL) {

  633.         jack_error("jack_port_set_name called with a NULL port name");

  634.         return -1;

  635.     } else {

  636.         JackClient* client = NULL;

  637.         for (int i = 0; i < CLIENT_NUM; i++) {

  638.             // Find a valid client

  639.             if ((client = JackGlobals::fClientTable[i])) {

  640.                 break;

  641.             }

  642.         }

  643.         return (client) ? client->PortRename(myport, name) : -1;

  644.     }

  645. }

  646. 

  647. LIB_EXPORT int jack_port_set_alias(jack_port_t* port, const char* name)

  648. {

  649. #ifdef __CLIENTDEBUG__

  650.     JackGlobals::CheckContext("jack_port_set_alias");

  651. #endif

  652.     uintptr_t port_aux = (uintptr_t)port;

  653.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  654.     if (!CheckPort(myport)) {

  655.         jack_error("jack_port_set_alias called with an incorrect port %ld", myport);

  656.         return -1;

  657.     } else if (name == NULL) {

  658.         jack_error("jack_port_set_alias called with a NULL port name");

  659.         return -1;

  660.     } else {

  661.         JackGraphManager* manager = GetGraphManager();

  662.         return (manager ? manager->GetPort(myport)->SetAlias(name) : -1);

  663.     }

  664. }

  665. 

  666. LIB_EXPORT int jack_port_unset_alias(jack_port_t* port, const char* name)

  667. {

  668. #ifdef __CLIENTDEBUG__

  669.     JackGlobals::CheckContext("jack_port_unset_alias");

  670. #endif

  671.     uintptr_t port_aux = (uintptr_t)port;

  672.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  673.     if (!CheckPort(myport)) {

  674.         jack_error("jack_port_unset_alias called with an incorrect port %ld", myport);

  675.         return -1;

  676.     } else if (name == NULL) {

  677.         jack_error("jack_port_unset_alias called with a NULL port name");

  678.         return -1;

  679.     } else {

  680.         JackGraphManager* manager = GetGraphManager();

  681.         return (manager ? manager->GetPort(myport)->UnsetAlias(name) : -1);

  682.     }

  683. }

  684. 

  685. LIB_EXPORT int jack_port_get_aliases(const jack_port_t* port, char* const aliases[2])

  686. {

  687. #ifdef __CLIENTDEBUG__

  688.     JackGlobals::CheckContext("jack_port_get_aliases");

  689. #endif

  690.     uintptr_t port_aux = (uintptr_t)port;

  691.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  692.     if (!CheckPort(myport)) {

  693.         jack_error("jack_port_get_aliases called with an incorrect port %ld", myport);

  694.         return -1;

  695.     } else {

  696.         JackGraphManager* manager = GetGraphManager();

  697.         return (manager ? manager->GetPort(myport)->GetAliases(aliases) : -1);

  698.     }

  699. }

  700. 

  701. LIB_EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)

  702. {

  703. #ifdef __CLIENTDEBUG__

  704.     JackGlobals::CheckContext("jack_port_request_monitor");

  705. #endif

  706.     uintptr_t port_aux = (uintptr_t)port;

  707.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  708.     if (!CheckPort(myport)) {

  709.         jack_error("jack_port_request_monitor called with an incorrect port %ld", myport);

  710.         return -1;

  711.     } else {

  712.         JackGraphManager* manager = GetGraphManager();

  713.         return (manager ? manager->RequestMonitor(myport, onoff) : -1);

  714.     }

  715. }

  716. 

  717. LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)

  718. {

  719. #ifdef __CLIENTDEBUG__

  720.     JackGlobals::CheckContext("jack_port_request_monitor_by_name");

  721. #endif

  722.     JackClient* client = (JackClient*)ext_client;

  723.     if (client == NULL) {

  724.         jack_error("jack_port_request_monitor_by_name called with a NULL client");

  725.         return -1;

  726.     } else {

  727.         JackGraphManager* manager = GetGraphManager();

  728.         if (!manager)

  729.             return -1;

  730.         jack_port_id_t myport = manager->GetPort(port_name);

  731.         if (!CheckPort(myport)) {

  732.             jack_error("jack_port_request_monitor_by_name called with an incorrect port %s", port_name);

  733.             return -1;

  734.         } else {

  735.             return manager->RequestMonitor(myport, onoff);

  736.         }

  737.     }

  738. }

  739. 

  740. LIB_EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)

  741. {

  742. #ifdef __CLIENTDEBUG__

  743.     JackGlobals::CheckContext("jack_port_ensure_monitor");

  744. #endif

  745.     uintptr_t port_aux = (uintptr_t)port;

  746.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  747.     if (!CheckPort(myport)) {

  748.         jack_error("jack_port_ensure_monitor called with an incorrect port %ld", myport);

  749.         return -1;

  750.     } else {

  751.         JackGraphManager* manager = GetGraphManager();

  752.         return (manager ? manager->GetPort(myport)->EnsureMonitor(onoff) : -1);

  753.     }

  754. }

  755. 

  756. LIB_EXPORT int jack_port_monitoring_input(jack_port_t* port)

  757. {

  758. #ifdef __CLIENTDEBUG__

  759.     JackGlobals::CheckContext("jack_port_monitoring_input");

  760. #endif

  761.     uintptr_t port_aux = (uintptr_t)port;

  762.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  763.     if (!CheckPort(myport)) {

  764.         jack_error("jack_port_monitoring_input called with an incorrect port %ld", myport);

  765.         return -1;

  766.     } else {

  767.         JackGraphManager* manager = GetGraphManager();

  768.         return (manager ? manager->GetPort(myport)->MonitoringInput() : -1);

  769.     }

  770. }

  771. 

  772. LIB_EXPORT int jack_is_realtime(jack_client_t* ext_client)

  773. {

  774. #ifdef __CLIENTDEBUG__

  775.     JackGlobals::CheckContext("jack_is_realtime");

  776. #endif

  777.     JackClient* client = (JackClient*)ext_client;

  778.     if (client == NULL) {

  779.         jack_error("jack_is_realtime called with a NULL client");

  780.         return -1;

  781.     } else {

  782.         JackEngineControl* control = GetEngineControl();

  783.         return (control ? control->fRealTime : -1);

  784.     }

  785. }

  786. 

  787. LIB_EXPORT void jack_on_shutdown(jack_client_t* ext_client, JackShutdownCallback callback, void* arg)

  788. {

  789. #ifdef __CLIENTDEBUG__

  790.     JackGlobals::CheckContext("jack_on_shutdown");

  791. #endif

  792.     JackClient* client = (JackClient*)ext_client;

  793.     if (client == NULL) {

  794.         jack_error("jack_on_shutdown called with a NULL client");

  795.     } else {

  796.         client->OnShutdown(callback, arg);

  797.     }

  798. }

  799. 

  800. LIB_EXPORT void jack_on_info_shutdown(jack_client_t* ext_client, JackInfoShutdownCallback callback, void* arg)

  801. {

  802. #ifdef __CLIENTDEBUG__

  803.     JackGlobals::CheckContext("jack_on_info_shutdown");

  804. #endif

  805.     JackClient* client = (JackClient*)ext_client;

  806.     if (client == NULL) {

  807.         jack_error("jack_on_info_shutdown called with a NULL client");

  808.     } else {

  809.         client->OnInfoShutdown(callback, arg);

  810.     }

  811. }

  812. 

  813. LIB_EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)

  814. {

  815. #ifdef __CLIENTDEBUG__

  816.     JackGlobals::CheckContext("jack_set_process_callback");

  817. #endif

  818.     JackClient* client = (JackClient*)ext_client;

  819.     if (client == NULL) {

  820.         jack_error("jack_set_process_callback called with a NULL client");

  821.         return -1;

  822.     } else {

  823.         return client->SetProcessCallback(callback, arg);

  824.     }

  825. }

  826. 

  827. LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t* ext_client, int status)

  828. {

  829. #ifdef __CLIENTDEBUG__

  830.     JackGlobals::CheckContext("jack_thread_wait");

  831. #endif

  832.     JackClient* client = (JackClient*)ext_client;

  833.     if (client == NULL) {

  834.         jack_error("jack_thread_wait called with a NULL client");

  835.         return 0;

  836.     } else {

  837.         jack_error("jack_thread_wait: deprecated, use jack_cycle_wait/jack_cycle_signal");

  838.         return 0;

  839.     }

  840. }

  841. 

  842. LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t* ext_client)

  843. {

  844. #ifdef __CLIENTDEBUG__

  845.     JackGlobals::CheckContext("jack_cycle_wait");

  846. #endif

  847.     JackClient* client = (JackClient*)ext_client;

  848.     if (client == NULL) {

  849.         jack_error("jack_cycle_wait called with a NULL client");

  850.         return 0;

  851.     } else {

  852.         return client->CycleWait();

  853.     }

  854. }

  855. 

  856. LIB_EXPORT void jack_cycle_signal(jack_client_t* ext_client, int status)

  857. {

  858. #ifdef __CLIENTDEBUG__

  859.     JackGlobals::CheckContext("jack_cycle_signal");

  860. #endif

  861.     JackClient* client = (JackClient*)ext_client;

  862.     if (client == NULL) {

  863.         jack_error("jack_cycle_signal called with a NULL client");

  864.     } else {

  865.         client->CycleSignal(status);

  866.     }

  867. }

  868. 

  869. LIB_EXPORT int jack_set_process_thread(jack_client_t* ext_client, JackThreadCallback fun, void *arg)

  870. {

  871. #ifdef __CLIENTDEBUG__

  872.     JackGlobals::CheckContext("jack_set_process_thread");

  873. #endif

  874.     JackClient* client = (JackClient*)ext_client;

  875.     if (client == NULL) {

  876.         jack_error("jack_set_process_thread called with a NULL client");

  877.         return -1;

  878.     } else {

  879.         return client->SetProcessThread(fun, arg);

  880.     }

  881. }

  882. 

  883. LIB_EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)

  884. {

  885. #ifdef __CLIENTDEBUG__

  886.     JackGlobals::CheckContext("jack_set_freewheel_callback");

  887. #endif

  888.     JackClient* client = (JackClient*)ext_client;

  889.     if (client == NULL) {

  890.         jack_error("jack_set_freewheel_callback called with a NULL client");

  891.         return -1;

  892.     } else {

  893.         return client->SetFreewheelCallback(freewheel_callback, arg);

  894.     }

  895. }

  896. 

  897. LIB_EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)

  898. {

  899. #ifdef __CLIENTDEBUG__

  900.     JackGlobals::CheckContext("jack_set_freewheel");

  901. #endif

  902.     JackClient* client = (JackClient*)ext_client;

  903.     if (client == NULL) {

  904.         jack_error("jack_set_freewheel called with a NULL client");

  905.         return -1;

  906.     } else {

  907.         return client->SetFreeWheel(onoff);

  908.     }

  909. }

  910. 

  911. LIB_EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer_size)

  912. {

  913. #ifdef __CLIENTDEBUG__

  914.     JackGlobals::CheckContext("jack_set_buffer_size");

  915. #endif

  916.     JackClient* client = (JackClient*)ext_client;

  917.     if (client == NULL) {

  918.         jack_error("jack_set_buffer_size called with a NULL client");

  919.         return -1;

  920.     } else if (!CheckBufferSize(buffer_size)) {

  921.         return -1;

  922.     } else {

  923.         return client->SetBufferSize(buffer_size);

  924.     }

  925. }

  926. 

  927. LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)

  928. {

  929. #ifdef __CLIENTDEBUG__

  930.     JackGlobals::CheckContext("jack_set_buffer_size_callback");

  931. #endif

  932.     JackClient* client = (JackClient*)ext_client;

  933.     if (client == NULL) {

  934.         jack_error("jack_set_buffer_size_callback called with a NULL client");

  935.         return -1;

  936.     } else {

  937.         return client->SetBufferSizeCallback(bufsize_callback, arg);

  938.     }

  939. }

  940. 

  941. LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg)

  942. {

  943. #ifdef __CLIENTDEBUG__

  944.     JackGlobals::CheckContext("jack_set_sample_rate_callback");

  945. #endif

  946.     JackClient* client = (JackClient*)ext_client;

  947.     if (client == NULL) {

  948.         jack_error("jack_set_sample_rate_callback called with a NULL client");

  949.         return -1;

  950.     } else {

  951.         return client->SetSampleRateCallback(srate_callback, arg);

  952.     }

  953. }

  954. 

  955. LIB_EXPORT int jack_set_client_registration_callback(jack_client_t* ext_client, JackClientRegistrationCallback registration_callback, void* arg)

  956. {

  957. #ifdef __CLIENTDEBUG__

  958.     JackGlobals::CheckContext("jack_set_client_registration_callback");

  959. #endif

  960.     JackClient* client = (JackClient*)ext_client;

  961.     if (client == NULL) {

  962.         jack_error("jack_set_client_registration_callback called with a NULL client");

  963.         return -1;

  964.     } else {

  965.         return client->SetClientRegistrationCallback(registration_callback, arg);

  966.     }

  967. }

  968. 

  969. LIB_EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)

  970. {

  971. #ifdef __CLIENTDEBUG__

  972.     JackGlobals::CheckContext("jack_set_port_registration_callback");

  973. #endif

  974.     JackClient* client = (JackClient*)ext_client;

  975.     if (client == NULL) {

  976.         jack_error("jack_set_port_registration_callback called with a NULL client");

  977.         return -1;

  978.     } else {

  979.         return client->SetPortRegistrationCallback(registration_callback, arg);

  980.     }

  981. }

  982. 

  983. LIB_EXPORT int jack_set_port_connect_callback(jack_client_t* ext_client, JackPortConnectCallback portconnect_callback, void* arg)

  984. {

  985. #ifdef __CLIENTDEBUG__

  986.     JackGlobals::CheckContext("jack_set_port_connect_callback");

  987. #endif

  988.     JackClient* client = (JackClient*)ext_client;

  989.     if (client == NULL) {

  990.         jack_error("jack_set_port_connect_callback called with a NULL client");

  991.         return -1;

  992.     } else {

  993.         return client->SetPortConnectCallback(portconnect_callback, arg);

  994.     }

  995. }

  996. 

  997. LIB_EXPORT int jack_set_port_rename_callback(jack_client_t* ext_client, JackPortRenameCallback rename_callback, void* arg)

  998. {

  999. #ifdef __CLIENTDEBUG__

  1000.     JackGlobals::CheckContext("jack_set_port_rename_callback");

  1001. #endif

  1002.     JackClient* client = (JackClient*)ext_client;

  1003.     if (client == NULL) {

  1004.         jack_error("jack_set_port_rename_callback called with a NULL client");

  1005.         return -1;

  1006.     } else {

  1007.         return client->SetPortRenameCallback(rename_callback, arg);

  1008.     }

  1009. }

  1010. 

  1011. LIB_EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)

  1012. {

  1013. #ifdef __CLIENTDEBUG__

  1014.     JackGlobals::CheckContext("jack_set_graph_order_callback");

  1015. #endif

  1016.     JackClient* client = (JackClient*)ext_client;

  1017.     jack_log("jack_set_graph_order_callback ext_client %x client %x ", ext_client, client);

  1018.     if (client == NULL) {

  1019.         jack_error("jack_set_graph_order_callback called with a NULL client");

  1020.         return -1;

  1021.     } else {

  1022.         return client->SetGraphOrderCallback(graph_callback, arg);

  1023.     }

  1024. }

  1025. 

  1026. LIB_EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xrun_callback, void* arg)

  1027. {

  1028. #ifdef __CLIENTDEBUG__

  1029.     JackGlobals::CheckContext("jack_set_xrun_callback");

  1030. #endif

  1031.     JackClient* client = (JackClient*)ext_client;

  1032.     if (client == NULL) {

  1033.         jack_error("jack_set_xrun_callback called with a NULL client");

  1034.         return -1;

  1035.     } else {

  1036.         return client->SetXRunCallback(xrun_callback, arg);

  1037.     }

  1038. }

  1039. 

  1040. LIB_EXPORT int jack_set_latency_callback(jack_client_t* ext_client, JackLatencyCallback latency_callback, void *arg)

  1041. {

  1042. #ifdef __CLIENTDEBUG__

  1043.     JackGlobals::CheckContext("jack_set_latency_callback");

  1044. #endif

  1045.     JackClient* client = (JackClient*)ext_client;

  1046.     if (client == NULL) {

  1047.         jack_error("jack_set_latency_callback called with a NULL client");

  1048.         return -1;

  1049.     } else {

  1050.         return client->SetLatencyCallback(latency_callback, arg);

  1051.     }

  1052. }

  1053. 

  1054. LIB_EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg)

  1055. {

  1056. #ifdef __CLIENTDEBUG__

  1057.     JackGlobals::CheckContext("jack_set_thread_init_callback");

  1058. #endif

  1059.     JackClient* client = (JackClient*)ext_client;

  1060.     jack_log("jack_set_thread_init_callback ext_client %x client %x ", ext_client, client);

  1061.     if (client == NULL) {

  1062.         jack_error("jack_set_thread_init_callback called with a NULL client");

  1063.         return -1;

  1064.     } else {

  1065.         return client->SetInitCallback(init_callback, arg);

  1066.     }

  1067. }

  1068. 

  1069. LIB_EXPORT int jack_activate(jack_client_t* ext_client)

  1070. {

  1071. #ifdef __CLIENTDEBUG__

  1072.     JackGlobals::CheckContext("jack_activate");

  1073. #endif

  1074.     JackClient* client = (JackClient*)ext_client;

  1075.     if (client == NULL) {

  1076.         jack_error("jack_activate called with a NULL client");

  1077.         return -1;

  1078.     } else {

  1079.         return client->Activate();

  1080.     }

  1081. }

  1082. 

  1083. LIB_EXPORT int jack_deactivate(jack_client_t* ext_client)

  1084. {

  1085. #ifdef __CLIENTDEBUG__

  1086.     JackGlobals::CheckContext("jack_deactivate");

  1087. #endif

  1088.     JackClient* client = (JackClient*)ext_client;

  1089.     if (client == NULL) {

  1090.         jack_error("jack_deactivate called with a NULL client");

  1091.         return -1;

  1092.     } else {

  1093.         return client->Deactivate();

  1094.     }

  1095. }

  1096. 

  1097. LIB_EXPORT jack_port_t* jack_port_register(jack_client_t* ext_client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)

  1098. {

  1099. #ifdef __CLIENTDEBUG__

  1100.     JackGlobals::CheckContext("jack_port_register");

  1101. #endif

  1102.     JackClient* client = (JackClient*)ext_client;

  1103.     if (client == NULL) {

  1104.         jack_error("jack_port_register called with a NULL client");

  1105.         return NULL;

  1106.     } else if ((port_name == NULL) || (port_type == NULL)) {

  1107.         jack_error("jack_port_register called with a NULL port name or a NULL port_type");

  1108.         return NULL;

  1109.     } else {

  1110.         return (jack_port_t *)((uintptr_t)client->PortRegister(port_name, port_type, flags, buffer_size));

  1111.     }

  1112. }

  1113. 

  1114. LIB_EXPORT int jack_port_unregister(jack_client_t* ext_client, jack_port_t* port)

  1115. {

  1116. #ifdef __CLIENTDEBUG__

  1117.     JackGlobals::CheckContext("jack_port_unregister");

  1118. #endif

  1119.     JackClient* client = (JackClient*)ext_client;

  1120.     if (client == NULL) {

  1121.         jack_error("jack_port_unregister called with a NULL client");

  1122.         return -1;

  1123.     }

  1124.     uintptr_t port_aux = (uintptr_t)port;

  1125.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1126.     if (!CheckPort(myport)) {

  1127.         jack_error("jack_port_unregister called with an incorrect port %ld", myport);

  1128.         return -1;

  1129.     }

  1130.     return client->PortUnRegister(myport);

  1131. }

  1132. 

  1133. LIB_EXPORT int jack_port_is_mine(const jack_client_t* ext_client, const jack_port_t* port)

  1134. {

  1135. #ifdef __CLIENTDEBUG__

  1136.     JackGlobals::CheckContext("jack_port_is_mine");

  1137. #endif

  1138.     JackClient* client = (JackClient*)ext_client;

  1139.     if (client == NULL) {

  1140.         jack_error("jack_port_is_mine called with a NULL client");

  1141.         return -1;

  1142.     }

  1143.     uintptr_t port_aux = (uintptr_t)port;

  1144.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1145.     if (!CheckPort(myport)) {

  1146.         jack_error("jack_port_is_mine called with an incorrect port %ld", myport);

  1147.         return -1;

  1148.     }

  1149.     return client->PortIsMine(myport);

  1150. }

  1151. 

  1152. LIB_EXPORT const char** jack_port_get_connections(const jack_port_t* port)

  1153. {

  1154. #ifdef __CLIENTDEBUG__

  1155.     JackGlobals::CheckContext("jack_port_get_connections");

  1156. #endif

  1157.     uintptr_t port_aux = (uintptr_t)port;

  1158.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1159.     if (!CheckPort(myport)) {

  1160.         jack_error("jack_port_get_connections called with an incorrect port %ld", myport);

  1161.         return NULL;

  1162.     } else {

  1163.         WaitGraphChange();

  1164.         JackGraphManager* manager = GetGraphManager();

  1165.         return (manager ? manager->GetConnections(myport) : NULL);

  1166.     }

  1167. }

  1168. 

  1169. // Calling client does not need to "own" the port

  1170. LIB_EXPORT const char** jack_port_get_all_connections(const jack_client_t* ext_client, const jack_port_t* port)

  1171. {

  1172. #ifdef __CLIENTDEBUG__

  1173.     JackGlobals::CheckContext("jack_port_get_all_connections");

  1174. #endif

  1175.     JackClient* client = (JackClient*)ext_client;

  1176.     if (client == NULL) {

  1177.         jack_error("jack_port_get_all_connections called with a NULL client");

  1178.         return NULL;

  1179.     }

  1180. 

  1181.     uintptr_t port_aux = (uintptr_t)port;

  1182.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1183.     if (!CheckPort(myport)) {

  1184.         jack_error("jack_port_get_all_connections called with an incorrect port %ld", myport);

  1185.         return NULL;

  1186.     } else {

  1187.         WaitGraphChange();

  1188.         JackGraphManager* manager = GetGraphManager();

  1189.         return (manager ? manager->GetConnections(myport) : NULL);

  1190.     }

  1191. }

  1192. 

  1193. LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t* ext_client, jack_port_t* port)

  1194. {

  1195. #ifdef __CLIENTDEBUG__

  1196.     JackGlobals::CheckContext("jack_port_get_total_latency");

  1197. #endif

  1198.     JackClient* client = (JackClient*)ext_client;

  1199.     if (client == NULL) {

  1200.         jack_error("jack_port_get_total_latency called with a NULL client");

  1201.         return 0;

  1202.     }

  1203. 

  1204.     uintptr_t port_aux = (uintptr_t)port;

  1205.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1206.     if (!CheckPort(myport)) {

  1207.         jack_error("jack_port_get_total_latency called with an incorrect port %ld", myport);

  1208.         return 0;

  1209.     } else {

  1210.         WaitGraphChange();

  1211.         JackGraphManager* manager = GetGraphManager();

  1212.         if (manager) {

  1213.             manager->ComputeTotalLatency(myport);

  1214.             return manager->GetPort(myport)->GetTotalLatency();

  1215.         } else {

  1216.             return 0;

  1217.         }

  1218.     }

  1219. }

  1220. 

  1221. LIB_EXPORT int jack_connect(jack_client_t* ext_client, const char* src, const char* dst)

  1222. {

  1223. #ifdef __CLIENTDEBUG__

  1224.     JackGlobals::CheckContext("jack_connect");

  1225. #endif

  1226.     JackClient* client = (JackClient*)ext_client;

  1227.     if (client == NULL) {

  1228.         jack_error("jack_connect called with a NULL client");

  1229.         return -1;

  1230.     } else if ((src == NULL) || (dst == NULL)) {

  1231.         jack_error("jack_connect called with a NULL port name");

  1232.         return -1;

  1233.     } else {

  1234.         return client->PortConnect(src, dst);

  1235.     }

  1236. }

  1237. 

  1238. LIB_EXPORT int jack_disconnect(jack_client_t* ext_client, const char* src, const char* dst)

  1239. {

  1240. #ifdef __CLIENTDEBUG__

  1241.     JackGlobals::CheckContext("jack_disconnect");

  1242. #endif

  1243.     JackClient* client = (JackClient*)ext_client;

  1244.     if (client == NULL) {

  1245.         jack_error("jack_disconnect called with a NULL client");

  1246.         return -1;

  1247.     } else if ((src == NULL) || (dst == NULL)) {

  1248.         jack_error("jack_connect called with a NULL port name");

  1249.         return -1;

  1250.     } else {

  1251.         return client->PortDisconnect(src, dst);

  1252.     }

  1253. }

  1254. 

  1255. LIB_EXPORT int jack_port_disconnect(jack_client_t* ext_client, jack_port_t* src)

  1256. {

  1257. #ifdef __CLIENTDEBUG__

  1258.     JackGlobals::CheckContext("jack_port_disconnect");

  1259. #endif

  1260.     JackClient* client = (JackClient*)ext_client;

  1261.     if (client == NULL) {

  1262.         jack_error("jack_port_disconnect called with a NULL client");

  1263.         return -1;

  1264.     }

  1265.     uintptr_t port_aux = (uintptr_t)src;

  1266.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1267.     if (!CheckPort(myport)) {

  1268.         jack_error("jack_port_disconnect called with an incorrect port %ld", myport);

  1269.         return -1;

  1270.     }

  1271.     return client->PortDisconnect(myport);

  1272. }

  1273. 

  1274. LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t* ext_client)

  1275. {

  1276. #ifdef __CLIENTDEBUG__

  1277.     JackGlobals::CheckContext("jack_get_sample_rate");

  1278. #endif

  1279.     JackClient* client = (JackClient*)ext_client;

  1280.     if (client == NULL) {

  1281.         jack_error("jack_get_sample_rate called with a NULL client");

  1282.         return 0;

  1283.     } else {

  1284.         JackEngineControl* control = GetEngineControl();

  1285.         return (control ? control->fSampleRate : 0);

  1286.     }

  1287. }

  1288. 

  1289. LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t* ext_client)

  1290. {

  1291. #ifdef __CLIENTDEBUG__

  1292.     JackGlobals::CheckContext("jack_get_buffer_size");

  1293. #endif

  1294.     JackClient* client = (JackClient*)ext_client;

  1295.     if (client == NULL) {

  1296.         jack_error("jack_get_buffer_size called with a NULL client");

  1297.         return 0;

  1298.     } else {

  1299.         JackEngineControl* control = GetEngineControl();

  1300.         return (control ? control->fBufferSize : 0);

  1301.     }

  1302. }

  1303. 

  1304. LIB_EXPORT const char** jack_get_ports(jack_client_t* ext_client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)

  1305. {

  1306. #ifdef __CLIENTDEBUG__

  1307.     JackGlobals::CheckContext("jack_get_ports");

  1308. #endif

  1309.     JackClient* client = (JackClient*)ext_client;

  1310.     if (client == NULL) {

  1311.         jack_error("jack_get_ports called with a NULL client");

  1312.         return NULL;

  1313.     }

  1314.     JackGraphManager* manager = GetGraphManager();

  1315.     return (manager ? manager->GetPorts(port_name_pattern, type_name_pattern, flags) : NULL);

  1316. }

  1317. 

  1318. LIB_EXPORT jack_port_t* jack_port_by_name(jack_client_t* ext_client, const char* portname)

  1319. {

  1320. #ifdef __CLIENTDEBUG__

  1321.     JackGlobals::CheckContext("jack_port_by_name");

  1322. #endif

  1323.     JackClient* client = (JackClient*)ext_client;

  1324.     if (client == NULL) {

  1325.         jack_error("jack_get_ports called with a NULL client");

  1326.         return 0;

  1327.     }

  1328. 

  1329.     if (portname == NULL) {

  1330.         jack_error("jack_port_by_name called with a NULL port name");

  1331.         return NULL;

  1332.     } else {

  1333.         JackGraphManager* manager = GetGraphManager();

  1334.         if (!manager)

  1335.             return NULL;

  1336.         int res = manager->GetPort(portname); // returns a port index at least > 1

  1337.         return (res == NO_PORT) ? NULL : (jack_port_t*)((uintptr_t)res);

  1338.     }

  1339. }

  1340. 

  1341. LIB_EXPORT jack_port_t* jack_port_by_id(jack_client_t* ext_client, jack_port_id_t id)

  1342. {

  1343. #ifdef __CLIENTDEBUG__

  1344.     JackGlobals::CheckContext("jack_port_by_id");

  1345. #endif

  1346.     /* jack_port_t* type is actually the port index */

  1347.     return (jack_port_t*)((uintptr_t)id);

  1348. }

  1349. 

  1350. LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t* ext_client)

  1351. {

  1352. #ifdef __CLIENTDEBUG__

  1353.     JackGlobals::CheckContext("jack_engine_takeover_timebase");

  1354. #endif

  1355.     JackClient* client = (JackClient*)ext_client;

  1356.     if (client == NULL) {

  1357.         jack_error("jack_engine_takeover_timebase called with a NULL client");

  1358.         return -1;

  1359.     } else {

  1360.         jack_error("jack_engine_takeover_timebase: deprecated\n");

  1361.         return 0;

  1362.     }

  1363. }

  1364. 

  1365. LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* ext_client)

  1366. {

  1367. #ifdef __CLIENTDEBUG__

  1368.     JackGlobals::CheckContext("jack_frames_since_cycle_start");

  1369. #endif

  1370.     JackTimer timer;

  1371.     JackEngineControl* control = GetEngineControl();

  1372.     if (control) {

  1373.         control->ReadFrameTime(&timer);

  1374.         return timer.FramesSinceCycleStart(GetMicroSeconds(), control->fSampleRate);

  1375.     } else {

  1376.         return 0;

  1377.     }

  1378. }

  1379. 

  1380. LIB_EXPORT jack_time_t jack_get_time()

  1381. {

  1382. #ifdef __CLIENTDEBUG__

  1383.     JackGlobals::CheckContext("jack_get_time");

  1384. #endif

  1385.     return GetMicroSeconds();

  1386. }

  1387. 

  1388. LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t* ext_client, jack_nframes_t frames)

  1389. {

  1390. #ifdef __CLIENTDEBUG__

  1391.     JackGlobals::CheckContext("jack_frames_to_time");

  1392. #endif

  1393.     JackClient* client = (JackClient*)ext_client;

  1394.     if (client == NULL) {

  1395.         jack_error("jack_frames_to_time called with a NULL client");

  1396.         return 0;

  1397.     } else {

  1398.         JackTimer timer;

  1399.         JackEngineControl* control = GetEngineControl();

  1400.         if (control) {

  1401.             control->ReadFrameTime(&timer);

  1402.             return timer.Frames2Time(frames, control->fBufferSize);

  1403.         } else {

  1404.             return 0;

  1405.         }

  1406.     }

  1407. }

  1408. 

  1409. LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t* ext_client, jack_time_t time)

  1410. {

  1411. #ifdef __CLIENTDEBUG__

  1412.     JackGlobals::CheckContext("jack_time_to_frames");

  1413. #endif

  1414.     JackClient* client = (JackClient*)ext_client;

  1415.     if (client == NULL) {

  1416.         jack_error("jack_time_to_frames called with a NULL client");

  1417.         return 0;

  1418.     } else {

  1419.         JackTimer timer;

  1420.         JackEngineControl* control = GetEngineControl();

  1421.         if (control) {

  1422.             control->ReadFrameTime(&timer);

  1423.             return timer.Time2Frames(time, control->fBufferSize);

  1424.         } else {

  1425.             return 0;

  1426.         }

  1427.     }

  1428. }

  1429. 

  1430. LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t* ext_client)

  1431. {

  1432. #ifdef __CLIENTDEBUG__

  1433.     JackGlobals::CheckContext("jack_frame_time");

  1434. #endif

  1435.     return jack_time_to_frames(ext_client, GetMicroSeconds());

  1436. }

  1437. 

  1438. LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t* ext_client)

  1439. {

  1440. #ifdef __CLIENTDEBUG__

  1441.     JackGlobals::CheckContext("jack_last_frame_time");

  1442. #endif

  1443.     JackEngineControl* control = GetEngineControl();

  1444.     return (control) ? control->fFrameTimer.ReadCurrentState()->CurFrame() : 0;

  1445. }

  1446. 

  1447. LIB_EXPORT float jack_cpu_load(jack_client_t* ext_client)

  1448. {

  1449. #ifdef __CLIENTDEBUG__

  1450.     JackGlobals::CheckContext("jack_cpu_load");

  1451. #endif

  1452.     JackClient* client = (JackClient*)ext_client;

  1453.     if (client == NULL) {

  1454.         jack_error("jack_cpu_load called with a NULL client");

  1455.         return 0.0f;

  1456.     } else {

  1457.         JackEngineControl* control = GetEngineControl();

  1458.         return (control ? control->fCPULoad :  0.0f);

  1459.     }

  1460. }

  1461. 

  1462. LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t* ext_client)

  1463. {

  1464. #ifdef __CLIENTDEBUG__

  1465.     JackGlobals::CheckContext("jack_client_thread_id");

  1466. #endif

  1467.     JackClient* client = (JackClient*)ext_client;

  1468.     if (client == NULL) {

  1469.         jack_error("jack_client_thread_id called with a NULL client");

  1470.         return (jack_native_thread_t)NULL;

  1471.     } else {

  1472.         return client->GetThreadID();

  1473.     }

  1474. }

  1475. 

  1476. LIB_EXPORT char* jack_get_client_name(jack_client_t* ext_client)

  1477. {

  1478. #ifdef __CLIENTDEBUG__

  1479.     JackGlobals::CheckContext("jack_get_client_name");

  1480. #endif

  1481.     JackClient* client = (JackClient*)ext_client;

  1482.     if (client == NULL) {

  1483.         jack_error("jack_get_client_name called with a NULL client");

  1484.         return NULL;

  1485.     } else {

  1486.         return client->GetClientControl()->fName;

  1487.     }

  1488. }

  1489. 

  1490. LIB_EXPORT int jack_client_name_size(void)

  1491. {

  1492.     return JACK_CLIENT_NAME_SIZE;

  1493. }

  1494. 

  1495. LIB_EXPORT int jack_port_name_size(void)

  1496. {

  1497.     return REAL_JACK_PORT_NAME_SIZE;

  1498. }

  1499. 

  1500. LIB_EXPORT int jack_port_type_size(void)

  1501. {

  1502.     return JACK_PORT_TYPE_SIZE;

  1503. }

  1504. 

  1505. LIB_EXPORT size_t jack_port_type_get_buffer_size(jack_client_t* ext_client, const char* port_type)

  1506. {

  1507. #ifdef __CLIENTDEBUG__

  1508.     JackGlobals::CheckContext("jack_port_type_get_buffer_size");

  1509. #endif

  1510.     JackClient* client = (JackClient*)ext_client;

  1511.     if (client == NULL) {

  1512.         jack_error("jack_port_type_get_buffer_size called with a NULL client");

  1513.         return 0;

  1514.     } else {

  1515.         jack_port_type_id_t port_id = GetPortTypeId(port_type);

  1516.         if (port_id == PORT_TYPES_MAX) {

  1517.             jack_error("jack_port_type_get_buffer_size called with an unknown port type = %s", port_type);

  1518.             return 0;

  1519.         } else {

  1520.             return GetPortType(port_id)->size();

  1521.         }

  1522.     }

  1523. }

  1524. 

  1525. // transport.h

  1526. LIB_EXPORT int jack_release_timebase(jack_client_t* ext_client)

  1527. {

  1528. #ifdef __CLIENTDEBUG__

  1529.     JackGlobals::CheckContext("jack_release_timebase");

  1530. #endif

  1531.     JackClient* client = (JackClient*)ext_client;

  1532.     if (client == NULL) {

  1533.         jack_error("jack_release_timebase called with a NULL client");

  1534.         return -1;

  1535.     } else {

  1536.         return client->ReleaseTimebase();

  1537.     }

  1538. }

  1539. 

  1540. LIB_EXPORT int jack_set_sync_callback(jack_client_t* ext_client, JackSyncCallback sync_callback, void *arg)

  1541. {

  1542. #ifdef __CLIENTDEBUG__

  1543.     JackGlobals::CheckContext("jack_set_sync_callback");

  1544. #endif

  1545.     JackClient* client = (JackClient*)ext_client;

  1546.     if (client == NULL) {

  1547.         jack_error("jack_set_sync_callback called with a NULL client");

  1548.         return -1;

  1549.     } else {

  1550.         return client->SetSyncCallback(sync_callback, arg);

  1551.     }

  1552. }

  1553. 

  1554. LIB_EXPORT int jack_set_sync_timeout(jack_client_t* ext_client, jack_time_t timeout)

  1555. {

  1556. #ifdef __CLIENTDEBUG__

  1557.     JackGlobals::CheckContext("jack_set_sync_timeout");

  1558. #endif

  1559.     JackClient* client = (JackClient*)ext_client;

  1560.     if (client == NULL) {

  1561.         jack_error("jack_set_sync_timeout called with a NULL client");

  1562.         return -1;

  1563.     } else {

  1564.         return client->SetSyncTimeout(timeout);

  1565.     }

  1566. }

  1567. 

  1568. LIB_EXPORT int jack_set_timebase_callback(jack_client_t* ext_client, int conditional, JackTimebaseCallback timebase_callback, void* arg)

  1569. {

  1570. #ifdef __CLIENTDEBUG__

  1571.     JackGlobals::CheckContext("jack_set_timebase_callback");

  1572. #endif

  1573.     JackClient* client = (JackClient*)ext_client;

  1574.     if (client == NULL) {

  1575.         jack_error("jack_set_timebase_callback called with a NULL client");

  1576.         return -1;

  1577.     } else {

  1578.         return client->SetTimebaseCallback(conditional, timebase_callback, arg);

  1579.     }

  1580. }

  1581. 

  1582. LIB_EXPORT int jack_transport_locate(jack_client_t* ext_client, jack_nframes_t frame)

  1583. {

  1584. #ifdef __CLIENTDEBUG__

  1585.     JackGlobals::CheckContext("jack_transport_locate");

  1586. #endif

  1587.     JackClient* client = (JackClient*)ext_client;

  1588.     if (client == NULL) {

  1589.         jack_error("jack_transport_locate called with a NULL client");

  1590.         return -1;

  1591.     } else {

  1592.         client->TransportLocate(frame);

  1593.         return 0;

  1594.     }

  1595. }

  1596. 

  1597. LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t* ext_client, jack_position_t* pos)

  1598. {

  1599. #ifdef __CLIENTDEBUG__

  1600.     JackGlobals::CheckContext("jack_transport_query");

  1601. #endif

  1602.     JackClient* client = (JackClient*)ext_client;

  1603.     if (client == NULL) {

  1604.         jack_error("jack_transport_query called with a NULL client");

  1605.         return JackTransportStopped;

  1606.     } else {

  1607.         return client->TransportQuery(pos);

  1608.     }

  1609. }

  1610. 

  1611. LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t* ext_client)

  1612. {

  1613. #ifdef __CLIENTDEBUG__

  1614.     JackGlobals::CheckContext("jack_get_current_transport_frame");

  1615. #endif

  1616.     JackClient* client = (JackClient*)ext_client;

  1617.     if (client == NULL) {

  1618.         jack_error("jack_get_current_transport_frame called with a NULL client");

  1619.         return 0;

  1620.     } else {

  1621.         return client->GetCurrentTransportFrame();

  1622.     }

  1623. }

  1624. 

  1625. LIB_EXPORT int jack_transport_reposition(jack_client_t* ext_client, const jack_position_t* pos)

  1626. {

  1627. #ifdef __CLIENTDEBUG__

  1628.     JackGlobals::CheckContext("jack_transport_reposition");

  1629. #endif

  1630.     JackClient* client = (JackClient*)ext_client;

  1631.     if (client == NULL) {

  1632.         jack_error("jack_transport_reposition called with a NULL client");

  1633.         return -1;

  1634.     } else {

  1635.         client->TransportReposition(pos);

  1636.         return 0;

  1637.     }

  1638. }

  1639. 

  1640. LIB_EXPORT void jack_transport_start(jack_client_t* ext_client)

  1641. {

  1642. #ifdef __CLIENTDEBUG__

  1643.     JackGlobals::CheckContext("jack_transport_start");

  1644. #endif

  1645.     JackClient* client = (JackClient*)ext_client;

  1646.     if (client == NULL) {

  1647.         jack_error("jack_transport_start called with a NULL client");

  1648.     } else {

  1649.         client->TransportStart();

  1650.     }

  1651. }

  1652. 

  1653. LIB_EXPORT void jack_transport_stop(jack_client_t* ext_client)

  1654. {

  1655. #ifdef __CLIENTDEBUG__

  1656.     JackGlobals::CheckContext("jack_transport_stop");

  1657. #endif

  1658.     JackClient* client = (JackClient*)ext_client;

  1659.     if (client == NULL) {

  1660.         jack_error("jack_transport_stop called with a NULL client");

  1661.     } else {

  1662.         client->TransportStop();

  1663.     }

  1664. }

  1665. 

  1666. // deprecated

  1667. LIB_EXPORT void jack_get_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)

  1668. {

  1669. #ifdef __CLIENTDEBUG__

  1670.     JackGlobals::CheckContext("jack_get_transport_info");

  1671. #endif

  1672.     jack_error("jack_get_transport_info: deprecated");

  1673.     if (tinfo)

  1674.         memset(tinfo, 0, sizeof(jack_transport_info_t));

  1675. }

  1676. 

  1677. LIB_EXPORT void jack_set_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)

  1678. {

  1679. #ifdef __CLIENTDEBUG__

  1680.     JackGlobals::CheckContext("jack_set_transport_info");

  1681. #endif

  1682.     jack_error("jack_set_transport_info: deprecated");

  1683.     if (tinfo)

  1684.         memset(tinfo, 0, sizeof(jack_transport_info_t));

  1685. }

  1686. 

  1687. // statistics.h

  1688. LIB_EXPORT float jack_get_max_delayed_usecs(jack_client_t* ext_client)

  1689. {

  1690. #ifdef __CLIENTDEBUG__

  1691.     JackGlobals::CheckContext("jack_get_max_delayed_usecs");

  1692. #endif

  1693.     JackClient* client = (JackClient*)ext_client;

  1694.     if (client == NULL) {

  1695.         jack_error("jack_get_max_delayed_usecs called with a NULL client");

  1696.         return 0.f;

  1697.     } else {

  1698.         JackEngineControl* control = GetEngineControl();

  1699.         return (control ? control->fMaxDelayedUsecs : 0.f);

  1700.     }

  1701.  }

  1702. 

  1703. LIB_EXPORT float jack_get_xrun_delayed_usecs(jack_client_t* ext_client)

  1704. {

  1705. #ifdef __CLIENTDEBUG__

  1706.     JackGlobals::CheckContext("jack_get_xrun_delayed_usecs");

  1707. #endif

  1708.     JackClient* client = (JackClient*)ext_client;

  1709.     if (client == NULL) {

  1710.         jack_error("jack_get_xrun_delayed_usecs called with a NULL client");

  1711.         return 0.f;

  1712.     } else {

  1713.         JackEngineControl* control = GetEngineControl();

  1714.         return (control ? control->fXrunDelayedUsecs : 0.f);

  1715.     }

  1716. }

  1717. 

  1718. LIB_EXPORT void jack_reset_max_delayed_usecs(jack_client_t* ext_client)

  1719. {

  1720. #ifdef __CLIENTDEBUG__

  1721.     JackGlobals::CheckContext("jack_reset_max_delayed_usecs");

  1722. #endif

  1723.     JackClient* client = (JackClient*)ext_client;

  1724.     if (client == NULL) {

  1725.         jack_error("jack_reset_max_delayed_usecs called with a NULL client");

  1726.     } else {

  1727.         JackEngineControl* control = GetEngineControl();

  1728.         control->ResetXRun();

  1729.     }

  1730. }

  1731. 

  1732. // thread.h

  1733. LIB_EXPORT int jack_client_real_time_priority(jack_client_t* ext_client)

  1734. {

  1735. #ifdef __CLIENTDEBUG__

  1736.     JackGlobals::CheckContext("jack_client_real_time_priority");

  1737. #endif

  1738.     JackClient* client = (JackClient*)ext_client;

  1739.     if (client == NULL) {

  1740.         jack_error("jack_client_real_time_priority called with a NULL client");

  1741.         return -1;

  1742.     } else {

  1743.         JackEngineControl* control = GetEngineControl();

  1744.         return (control->fRealTime) ? control->fClientPriority : -1;

  1745.     }

  1746. }

  1747. 

  1748. LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t* ext_client)

  1749. {

  1750. #ifdef __CLIENTDEBUG__

  1751.     JackGlobals::CheckContext("jack_client_max_real_time_priority");

  1752. #endif

  1753.     JackClient* client = (JackClient*)ext_client;

  1754.     if (client == NULL) {

  1755.         jack_error("jack_client_max_real_time_priority called with a NULL client");

  1756.         return -1;

  1757.     } else {

  1758.         JackEngineControl* control = GetEngineControl();

  1759.        return (control->fRealTime) ? control->fMaxClientPriority : -1;

  1760.     }

  1761. }

  1762. 

  1763. LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority)

  1764. {

  1765.     JackEngineControl* control = GetEngineControl();

  1766.     return (control ? JackThread::AcquireRealTimeImp(thread, priority, GetEngineControl()->fPeriod, GetEngineControl()->fComputation, GetEngineControl()->fConstraint) : -1);

  1767. }

  1768. 

  1769. LIB_EXPORT int jack_client_create_thread(jack_client_t* client,

  1770.                                      jack_native_thread_t *thread,

  1771.                                      int priority,

  1772.                                      int realtime,      /* boolean */

  1773.                                      thread_routine routine,

  1774.                                      void *arg)

  1775. {

  1776. #ifdef __CLIENTDEBUG__

  1777.     JackGlobals::CheckContext("jack_client_create_thread");

  1778. #endif

  1779.     JackEngineControl* control = GetEngineControl();

  1780.     int res = JackThread::StartImp(thread, priority, realtime, routine, arg);

  1781.     return (res == 0)

  1782.         ? ((realtime ? JackThread::AcquireRealTimeImp(*thread, priority,

  1783.             GetEngineControl()->fPeriod,

  1784.             GetEngineControl()->fComputation,

  1785.             GetEngineControl()->fConstraint) : res))

  1786.         : res;

  1787. }

  1788. 

  1789. LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread)

  1790. {

  1791.     return JackThread::DropRealTimeImp(thread);

  1792. }

  1793. 

  1794. LIB_EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread)

  1795. {

  1796. #ifdef __CLIENTDEBUG__

  1797.     JackGlobals::CheckContext("jack_client_stop_thread");

  1798. #endif

  1799.     return JackThread::StopImp(thread);

  1800. }

  1801. 

  1802. LIB_EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread)

  1803. {

  1804. #ifdef __CLIENTDEBUG__

  1805.     JackGlobals::CheckContext("jack_client_kill_thread");

  1806. #endif

  1807.     return JackThread::KillImp(thread);

  1808. }

  1809. 

  1810. #ifndef WIN32

  1811. LIB_EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc)

  1812. {

  1813.     JackGlobals::fJackThreadCreator = (jtc == NULL) ? pthread_create : jtc;

  1814. }

  1815. #endif

  1816. 

  1817. // intclient.h

  1818. LIB_EXPORT int jack_internal_client_new (const char* client_name,

  1819.                                      const char* load_name,

  1820.                                      const char* load_init)

  1821. {

  1822. #ifdef __CLIENTDEBUG__

  1823.     JackGlobals::CheckContext("jack_internal_client_new");

  1824. #endif

  1825.     jack_error("jack_internal_client_new: deprecated");

  1826.     return -1;

  1827. }

  1828. 

  1829. LIB_EXPORT void jack_internal_client_close (const char* client_name)

  1830. {

  1831. #ifdef __CLIENTDEBUG__

  1832.     JackGlobals::CheckContext("jack_internal_client_close");

  1833. #endif

  1834.     jack_error("jack_internal_client_close: deprecated");

  1835. }

  1836. 

  1837. LIB_EXPORT char* jack_get_internal_client_name(jack_client_t* ext_client, jack_intclient_t intclient)

  1838. {

  1839. #ifdef __CLIENTDEBUG__

  1840.     JackGlobals::CheckContext("jack_get_internal_client_name");

  1841. #endif

  1842.     JackClient* client = (JackClient*)ext_client;

  1843.     if (client == NULL) {

  1844.         jack_error("jack_get_internal_client_name called with a NULL client");

  1845.         return NULL;

  1846.     } else if (intclient >= CLIENT_NUM) {

  1847.         jack_error("jack_get_internal_client_name: incorrect client");

  1848.         return NULL;

  1849.     } else {

  1850.         return client->GetInternalClientName(intclient);

  1851.     }

  1852. }

  1853. 

  1854. LIB_EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t* ext_client, const char* client_name, jack_status_t* status)

  1855. {

  1856. #ifdef __CLIENTDEBUG__

  1857.     JackGlobals::CheckContext("jack_internal_client_handle");

  1858. #endif

  1859.     JackClient* client = (JackClient*)ext_client;

  1860.     if (client == NULL) {

  1861.         jack_error("jack_internal_client_handle called with a NULL client");

  1862.         return 0;

  1863.     } else {

  1864.         jack_status_t my_status;

  1865.         if (status == NULL)             /* no status from caller? */

  1866.             status = &my_status;        /* use local status word */

  1867.         *status = (jack_status_t)0;

  1868.         return client->InternalClientHandle(client_name, status);

  1869.     }

  1870. }

  1871. 

  1872. LIB_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)

  1873. {

  1874. #ifdef __CLIENTDEBUG__

  1875.     JackGlobals::CheckContext("jack_internal_client_load_aux");

  1876. #endif

  1877.     JackClient* client = (JackClient*)ext_client;

  1878.     if (client == NULL) {

  1879.         jack_error("jack_internal_client_load called with a NULL client");

  1880.         return 0;

  1881.     } else {

  1882.         jack_varargs_t va;

  1883.         jack_status_t my_status;

  1884. 

  1885.         if (status == NULL)             /* no status from caller? */

  1886.             status = &my_status;        /* use local status word */

  1887.         *status = (jack_status_t)0;

  1888. 

  1889.         /* validate parameters */

  1890.         if ((options & ~JackLoadOptions)) {

  1891.             int my_status1 = *status | (JackFailure | JackInvalidOption);

  1892.             *status = (jack_status_t)my_status1;

  1893.             return 0;

  1894.         }

  1895. 

  1896.         /* parse variable arguments */

  1897.         jack_varargs_parse(options, ap, &va);

  1898.         return client->InternalClientLoad(client_name, options, status, &va);

  1899.     }

  1900. }

  1901. 

  1902. LIB_EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client, const char* client_name, jack_options_t options, jack_status_t *status, ...)

  1903. {

  1904. #ifdef __CLIENTDEBUG__

  1905.     JackGlobals::CheckContext("jack_internal_client_load");

  1906. #endif

  1907.     va_list ap;

  1908.     va_start(ap, status);

  1909.     jack_intclient_t res = jack_internal_client_load_aux(client, client_name, options, status, ap);

  1910.     va_end(ap);

  1911.     return res;

  1912. }

  1913. 

  1914. LIB_EXPORT jack_status_t jack_internal_client_unload(jack_client_t* ext_client, jack_intclient_t intclient)

  1915. {

  1916. #ifdef __CLIENTDEBUG__

  1917.     JackGlobals::CheckContext("jack_internal_client_load");

  1918. #endif

  1919.     JackClient* client = (JackClient*)ext_client;

  1920.     if (client == NULL) {

  1921.         jack_error("jack_internal_client_unload called with a NULL client");

  1922.         return (jack_status_t)(JackNoSuchClient | JackFailure);

  1923.     } else if (intclient >= CLIENT_NUM) {

  1924.         jack_error("jack_internal_client_unload: incorrect client");

  1925.         return (jack_status_t)(JackNoSuchClient | JackFailure);

  1926.     } else {

  1927.         jack_status_t my_status;

  1928.         client->InternalClientUnload(intclient, &my_status);

  1929.         return my_status;

  1930.     }

  1931. }

  1932. 

  1933. LIB_EXPORT void jack_get_version(int *major_ptr,

  1934.                             int *minor_ptr,

  1935.                             int *micro_ptr,

  1936.                             int *proto_ptr)

  1937. {

  1938. #ifdef __CLIENTDEBUG__

  1939.     JackGlobals::CheckContext("jack_get_version");

  1940. #endif

  1941.     // FIXME: We need these comming from build system

  1942.     *major_ptr = 0;

  1943.     *minor_ptr = 0;

  1944.     *micro_ptr = 0;

  1945.     *proto_ptr = 0;

  1946. }

  1947. 

  1948. LIB_EXPORT const char* jack_get_version_string()

  1949. {

  1950. #ifdef __CLIENTDEBUG__

  1951.     JackGlobals::CheckContext("jack_get_version_string");

  1952. #endif

  1953.     return VERSION;

  1954. }

  1955. 

  1956. LIB_EXPORT void jack_free(void* ptr)

  1957. {

  1958. #ifdef __CLIENTDEBUG__

  1959.     JackGlobals::CheckContext("jack_free");

  1960. #endif

  1961.     if (ptr) {

  1962.         free(ptr);

  1963.     }

  1964. }

  1965. 

  1966. // session.h

  1967. LIB_EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg)

  1968. {

  1969. #ifdef __CLIENTDEBUG__

  1970.     JackGlobals::CheckContext("jack_set_session_callback");

  1971. #endif

  1972.     JackClient* client = (JackClient*)ext_client;

  1973.     jack_log("jack_set_session_callback ext_client %x client %x ", ext_client, client);

  1974.     if (client == NULL) {

  1975.         jack_error("jack_set_session_callback called with a NULL client");

  1976.         return -1;

  1977.     } else {

  1978.         return client->SetSessionCallback(session_callback, arg);

  1979.     }

  1980. }

  1981. 

  1982. LIB_EXPORT jack_session_command_t* jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char* path)

  1983. {

  1984. #ifdef __CLIENTDEBUG__

  1985.     JackGlobals::CheckContext("jack_session_notify");

  1986. #endif

  1987.     JackClient* client = (JackClient*)ext_client;

  1988.     jack_log("jack_session_notify ext_client %x client %x ", ext_client, client);

  1989.     if (client == NULL) {

  1990.         jack_error("jack_session_notify called with a NULL client");

  1991.         return NULL;

  1992.     } else {

  1993.         return client->SessionNotify(target, ev_type, path);

  1994.     }

  1995. }

  1996. 

  1997. LIB_EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event)

  1998. {

  1999. #ifdef __CLIENTDEBUG__

  2000.     JackGlobals::CheckContext("jack_session_reply");

  2001. #endif

  2002.     JackClient* client = (JackClient*)ext_client;

  2003.     jack_log("jack_session_reply ext_client %x client %x ", ext_client, client);

  2004.     if (client == NULL) {

  2005.         jack_error("jack_session_reply called with a NULL client");

  2006.         return -1;

  2007.     } else {

  2008.         return client->SessionReply(event);

  2009.     }

  2010. }

  2011. 

  2012. LIB_EXPORT void jack_session_event_free(jack_session_event_t* ev)

  2013. {

  2014. #ifdef __CLIENTDEBUG__

  2015.     JackGlobals::CheckContext("jack_session_event_free");

  2016. #endif

  2017.     if (ev) {

  2018.         if (ev->session_dir)

  2019.             free((void *)ev->session_dir);

  2020.         if (ev->client_uuid)

  2021.             free((void *)ev->client_uuid);

  2022.         if (ev->command_line)

  2023.             free(ev->command_line);

  2024.         free(ev);

  2025.     }

  2026. }

  2027. 

  2028. LIB_EXPORT char *jack_client_get_uuid(jack_client_t* ext_client)

  2029. {

  2030. #ifdef __CLIENTDEBUG__

  2031.     JackGlobals::CheckContext("jack_client_get_uuid");

  2032. #endif

  2033.     JackClient* client = (JackClient*)ext_client;

  2034.     if (client == NULL) {

  2035.         jack_error("jack_client_get_uuid called with a NULL client");

  2036.         return NULL;

  2037.     } else {

  2038.         char retval[16];

  2039.         snprintf(retval, sizeof(retval), "%d", client->GetClientControl()->fSessionID);

  2040.         return strdup(retval);

  2041.     }

  2042. }

  2043. 

  2044. LIB_EXPORT char* jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name)

  2045. {

  2046. #ifdef __CLIENTDEBUG__

  2047.     JackGlobals::CheckContext("jack_get_uuid_for_client_name");

  2048. #endif

  2049.     JackClient* client = (JackClient*)ext_client;

  2050.     jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);

  2051.     if (client == NULL) {

  2052.         jack_error("jack_get_uuid_for_client_name called with a NULL client");

  2053.         return NULL;

  2054.     } else {

  2055.         return client->GetUUIDForClientName(client_name);

  2056.     }

  2057. }

  2058. 

  2059. LIB_EXPORT char* jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid)

  2060. {

  2061. #ifdef __CLIENTDEBUG__

  2062.     JackGlobals::CheckContext("jack_get_client_name_by_uuid");

  2063. #endif

  2064.     JackClient* client = (JackClient*)ext_client;

  2065.     jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);

  2066.     if (client == NULL) {

  2067.         jack_error("jack_get_client_name_by_uuid called with a NULL client");

  2068.         return NULL;

  2069.     } else {

  2070.         return client->GetClientNameByUUID(client_uuid);

  2071.     }

  2072. }

  2073. 

  2074. LIB_EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* client_name, const char* uuid)

  2075. {

  2076. #ifdef __CLIENTDEBUG__

  2077.     JackGlobals::CheckContext("jack_reserve_client_name");

  2078. #endif

  2079.     JackClient* client = (JackClient*)ext_client;

  2080.     jack_log("jack_reserve_client_name ext_client %x client %x ", ext_client, client);

  2081.     if (client == NULL) {

  2082.         jack_error("jack_reserve_client_name called with a NULL client");

  2083.         return -1;

  2084.     } else {

  2085.         return client->ReserveClientName(client_name, uuid);

  2086.     }

  2087. }

  2088. 

  2089. LIB_EXPORT void jack_session_commands_free(jack_session_command_t *cmds)

  2090. {

  2091. #ifdef __CLIENTDEBUG__

  2092.     JackGlobals::CheckContext("jack_session_commands_free");

  2093. #endif

  2094. 

  2095.     if (!cmds)

  2096.         return;

  2097. 

  2098.     int i = 0;

  2099.     while (1) {

  2100.         if (cmds[i].client_name)

  2101.             free ((char *)cmds[i].client_name);

  2102.         if (cmds[i].command)

  2103.             free ((char *)cmds[i].command);

  2104.         if (cmds[i].uuid)

  2105.             free ((char *)cmds[i].uuid);

  2106.         else

  2107.             break;

  2108. 

  2109.         i += 1;

  2110.     }

  2111. 

  2112.     free(cmds);

  2113. }

  2114. 

  2115. LIB_EXPORT int jack_client_has_session_callback(jack_client_t* ext_client, const char* client_name)

  2116. {

  2117. #ifdef __CLIENTDEBUG__

  2118.     JackGlobals::CheckContext("jack_client_has_session_callback");

  2119. #endif

  2120.     JackClient* client = (JackClient*)ext_client;

  2121.     jack_log("jack_client_has_session_callback ext_client %x client %x ", ext_client, client);

  2122.     if (client == NULL) {

  2123.         jack_error("jack_client_has_session_callback called with a NULL client");

  2124.         return -1;

  2125.     } else {

  2126.         return client->ClientHasSessionCallback(client_name);

  2127.     }

  2128. }