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.
1535 Commits
7 Branches
43MB
Tree: 4086b3ca90
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4086b3ca90'
${ noResults }
jack2/common/JackAPI.cpp

1929 lines
61KB
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.     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.     EXPORT

  56.     const char *

  57.     jack_get_version_string();

  58. 

  59.     EXPORT jack_client_t * jack_client_open_aux (const char *client_name,

  60.             jack_options_t options,

  61.             jack_status_t *status, va_list ap);

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

  63.             jack_options_t options,

  64.             jack_status_t *status, ...);

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

  66.     EXPORT int jack_client_name_size (void);

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

  68.     EXPORT int jack_internal_client_new (const char *client_name,

  69.                                          const char *load_name,

  70.                                          const char *load_init);

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

  72.     EXPORT int jack_is_realtime (jack_client_t *client);

  73.     EXPORT void jack_on_shutdown (jack_client_t *client,

  74.                                   JackShutdownCallback shutdown_callback, void *arg);

  75.     EXPORT int jack_set_process_callback (jack_client_t *client,

  76.                                           JackProcessCallback process_callback,

  77.                                           void *arg);

  78.     EXPORT jack_nframes_t jack_thread_wait(jack_client_t *client, int status);

  79. 

  80.     // new

  81.     EXPORT jack_nframes_t jack_cycle_wait (jack_client_t*);

  82.     EXPORT void jack_cycle_signal (jack_client_t*, int status);

  83.     EXPORT int jack_set_process_thread(jack_client_t* client, JackThreadCallback fun, void *arg);

  84. 

  85.     EXPORT int jack_set_thread_init_callback (jack_client_t *client,

  86.             JackThreadInitCallback thread_init_callback,

  87.             void *arg);

  88.     EXPORT int jack_set_freewheel_callback (jack_client_t *client,

  89.                                             JackFreewheelCallback freewheel_callback,

  90.                                             void *arg);

  91.     EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);

  92.     EXPORT int jack_set_buffer_size (jack_client_t *client, jack_nframes_t nframes);

  93.     EXPORT int jack_set_buffer_size_callback (jack_client_t *client,

  94.             JackBufferSizeCallback bufsize_callback,

  95.             void *arg);

  96.     EXPORT int jack_set_sample_rate_callback (jack_client_t *client,

  97.             JackSampleRateCallback srate_callback,

  98.             void *arg);

  99.     EXPORT int jack_set_client_registration_callback (jack_client_t *,

  100.             JackClientRegistrationCallback

  101.             registration_callback, void *arg);

  102.     EXPORT int jack_set_port_registration_callback (jack_client_t *,

  103.             JackPortRegistrationCallback

  104.             registration_callback, void *arg);

  105.     EXPORT int jack_set_port_connect_callback (jack_client_t *,

  106.             JackPortConnectCallback

  107.             connect_callback, void *arg);

  108.     EXPORT int jack_set_port_rename_callback (jack_client_t *,

  109. 				    JackPortRenameCallback

  110. 				    rename_callback, void *arg);

  111.     EXPORT int jack_set_graph_order_callback (jack_client_t *,

  112.             JackGraphOrderCallback graph_callback,

  113.             void *);

  114.     EXPORT int jack_set_xrun_callback (jack_client_t *,

  115.                                        JackXRunCallback xrun_callback, void *arg);

  116.     EXPORT int jack_activate (jack_client_t *client);

  117.     EXPORT int jack_deactivate (jack_client_t *client);

  118.     EXPORT jack_port_t * jack_port_register (jack_client_t *client,

  119.             const char *port_name,

  120.             const char *port_type,

  121.             unsigned long flags,

  122.             unsigned long buffer_size);

  123.     EXPORT int jack_port_unregister (jack_client_t *, jack_port_t *);

  124.     EXPORT void * jack_port_get_buffer (jack_port_t *, jack_nframes_t);

  125.     EXPORT const char * jack_port_name (const jack_port_t *port);

  126.     EXPORT const char * jack_port_short_name (const jack_port_t *port);

  127.     EXPORT int jack_port_flags (const jack_port_t *port);

  128.     EXPORT const char * jack_port_type (const jack_port_t *port);

  129.     EXPORT jack_port_type_id_t jack_port_type_id (const jack_port_t *port);

  130.     EXPORT int jack_port_is_mine (const jack_client_t *, const jack_port_t *port);

  131.     EXPORT int jack_port_connected (const jack_port_t *port);

  132.     EXPORT int jack_port_connected_to (const jack_port_t *port,

  133.                                        const char *port_name);

  134.     EXPORT const char ** jack_port_get_connections (const jack_port_t *port);

  135.     EXPORT const char ** jack_port_get_all_connections (const jack_client_t *client,

  136.             const jack_port_t *port);

  137.     EXPORT int jack_port_tie (jack_port_t *src, jack_port_t *dst);

  138.     EXPORT int jack_port_untie (jack_port_t *port);

  139.     EXPORT jack_nframes_t jack_port_get_latency (jack_port_t *port);

  140.     EXPORT jack_nframes_t jack_port_get_total_latency (jack_client_t *,

  141.             jack_port_t *port);

  142.     EXPORT void jack_port_set_latency (jack_port_t *, jack_nframes_t);

  143.     EXPORT int jack_recompute_total_latency (jack_client_t*, jack_port_t* port);

  144.     EXPORT int jack_recompute_total_latencies (jack_client_t*);

  145.     EXPORT int jack_port_set_name (jack_port_t *port, const char *port_name);

  146.     EXPORT int jack_port_set_alias (jack_port_t *port, const char *alias);

  147.     EXPORT int jack_port_unset_alias (jack_port_t *port, const char *alias);

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

  149.     EXPORT int jack_port_request_monitor (jack_port_t *port, int onoff);

  150.     EXPORT int jack_port_request_monitor_by_name (jack_client_t *client,

  151.             const char *port_name, int onoff);

  152.     EXPORT int jack_port_ensure_monitor (jack_port_t *port, int onoff);

  153.     EXPORT int jack_port_monitoring_input (jack_port_t *port);

  154.     EXPORT int jack_connect (jack_client_t *,

  155.                              const char *source_port,

  156.                              const char *destination_port);

  157.     EXPORT int jack_disconnect (jack_client_t *,

  158.                                 const char *source_port,

  159.                                 const char *destination_port);

  160.     EXPORT int jack_port_disconnect (jack_client_t *, jack_port_t *);

  161.     EXPORT int jack_port_name_size(void);

  162.     EXPORT int jack_port_type_size(void);

  163.     EXPORT jack_nframes_t jack_get_sample_rate (jack_client_t *);

  164.     EXPORT jack_nframes_t jack_get_buffer_size (jack_client_t *);

  165.     EXPORT const char ** jack_get_ports (jack_client_t *,

  166.                                          const char *port_name_pattern,

  167.                                          const char *type_name_pattern,

  168.                                          unsigned long flags);

  169.     EXPORT jack_port_t * jack_port_by_name (jack_client_t *, const char *port_name);

  170.     EXPORT jack_port_t * jack_port_by_id (jack_client_t *client,

  171.                                           jack_port_id_t port_id);

  172.     EXPORT int jack_engine_takeover_timebase (jack_client_t *);

  173.     EXPORT jack_nframes_t jack_frames_since_cycle_start (const jack_client_t *);

  174.     EXPORT jack_time_t jack_get_time();

  175.     EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t time);

  176.     EXPORT jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames);

  177.     EXPORT jack_nframes_t jack_frame_time (const jack_client_t *);

  178.     EXPORT jack_nframes_t jack_last_frame_time (const jack_client_t *client);

  179.     EXPORT float jack_cpu_load (jack_client_t *client);

  180.     EXPORT pthread_t jack_client_thread_id (jack_client_t *);

  181.     EXPORT void jack_set_error_function (print_function);

  182.     EXPORT void jack_set_info_function (print_function);

  183. 

  184.     EXPORT float jack_get_max_delayed_usecs (jack_client_t *client);

  185.     EXPORT float jack_get_xrun_delayed_usecs (jack_client_t *client);

  186.     EXPORT void jack_reset_max_delayed_usecs (jack_client_t *client);

  187. 

  188.     EXPORT int jack_release_timebase (jack_client_t *client);

  189.     EXPORT int jack_set_sync_callback (jack_client_t *client,

  190.                                        JackSyncCallback sync_callback,

  191.                                        void *arg);

  192.     EXPORT int jack_set_sync_timeout (jack_client_t *client,

  193.                                       jack_time_t timeout);

  194.     EXPORT int jack_set_timebase_callback (jack_client_t *client,

  195.                                            int conditional,

  196.                                            JackTimebaseCallback timebase_callback,

  197.                                            void *arg);

  198.     EXPORT int jack_transport_locate (jack_client_t *client,

  199.                                       jack_nframes_t frame);

  200.     EXPORT jack_transport_state_t jack_transport_query (const jack_client_t *client,

  201.             jack_position_t *pos);

  202.     EXPORT jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client);

  203.     EXPORT int jack_transport_reposition (jack_client_t *client,

  204.                                           jack_position_t *pos);

  205.     EXPORT void jack_transport_start (jack_client_t *client);

  206.     EXPORT void jack_transport_stop (jack_client_t *client);

  207.     EXPORT void jack_get_transport_info (jack_client_t *client,

  208.                                          jack_transport_info_t *tinfo);

  209.     EXPORT void jack_set_transport_info (jack_client_t *client,

  210.                                          jack_transport_info_t *tinfo);

  211. 

  212.     EXPORT int jack_client_real_time_priority (jack_client_t*);

  213.     EXPORT int jack_client_max_real_time_priority (jack_client_t*);

  214.     EXPORT int jack_acquire_real_time_scheduling (pthread_t thread, int priority);

  215.     EXPORT int jack_client_create_thread (jack_client_t* client,

  216.                                           pthread_t *thread,

  217.                                           int priority,

  218.                                           int realtime, 	// boolean

  219.                                           thread_routine routine,

  220.                                           void *arg);

  221.     EXPORT int jack_drop_real_time_scheduling (pthread_t thread);

  222.     

  223.     EXPORT int jack_client_stop_thread (jack_client_t* client, pthread_t thread);

  224.     EXPORT int jack_client_kill_thread (jack_client_t* client, pthread_t thread);

  225.     EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc);

  226. 

  227.     EXPORT char * jack_get_internal_client_name (jack_client_t *client,

  228.             jack_intclient_t intclient);

  229.     EXPORT jack_intclient_t jack_internal_client_handle (jack_client_t *client,

  230.             const char *client_name,

  231.             jack_status_t *status);

  232.     EXPORT jack_intclient_t jack_internal_client_load (jack_client_t *client,

  233.             const char *client_name,

  234.             jack_options_t options,

  235.             jack_status_t *status, ...);

  236.     EXPORT jack_intclient_t jack_internal_client_load_aux (jack_client_t *client,

  237.             const char *client_name,

  238.             jack_options_t options,

  239.             jack_status_t *status, va_list ap);

  240. 

  241.     EXPORT jack_status_t jack_internal_client_unload (jack_client_t *client,

  242.             jack_intclient_t intclient);

  243. 

  244. #ifdef __cplusplus

  245. }

  246. #endif

  247. 

  248. static inline bool CheckPort(jack_port_id_t port_index)

  249. {

  250.     return (port_index > 0 && port_index < PORT_NUM);

  251. }

  252. 

  253. static inline bool CheckBufferSize(jack_nframes_t buffer_size)

  254. {

  255.     return (buffer_size <= BUFFER_SIZE_MAX);

  256. }

  257. 

  258. static inline void WaitGraphChange()

  259. {

  260.     /*

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

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

  263.     */

  264. 

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

  266.         JackGraphManager* manager = GetGraphManager();

  267.         JackEngineControl* control = GetEngineControl();

  268.         assert(manager);

  269.         assert(control);

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

  271.             jack_log("WaitGraphChange...");

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

  273.         }

  274.     }

  275. }

  276. 

  277. EXPORT void jack_set_error_function (print_function func)

  278. {

  279.     jack_error_callback = func;

  280. }

  281. 

  282. EXPORT void jack_set_info_function (print_function func)

  283. {

  284.     jack_info_callback = func;

  285. }

  286. 

  287. EXPORT jack_client_t* jack_client_new(const char* client_name)

  288. {

  289.     assert(JackGlobals::fOpenMutex);

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

  291.     jack_error("jack_client_new: deprecated");

  292.     int options = JackUseExactName;

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

  294.         options |= JackNoStartServer;

  295.     jack_client_t* res = jack_client_open_aux(client_name, (jack_options_t)options, NULL, NULL);

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

  297.     return res;

  298. }

  299. 

  300. EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)

  301. {

  302. #ifdef __CLIENTDEBUG__

  303.     JackLibGlobals::CheckContext();

  304. #endif

  305. #if defined(__x86_64__) || defined(__ppc64__)

  306.     uint64_t port_aux = (uint64_t)port;

  307. #else

  308.     uint32_t port_aux = (uint32_t)port;

  309. #endif

  310.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  311.     if (!CheckPort(myport)) {

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

  313.         return NULL;

  314.     } else {

  315.         JackGraphManager* manager = GetGraphManager();

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

  317.     }

  318. }

  319. 

  320. EXPORT const char* jack_port_name(const jack_port_t* port)

  321. {

  322. #ifdef __CLIENTDEBUG__

  323.     JackLibGlobals::CheckContext();

  324. #endif

  325. #if defined(__x86_64__) || defined(__ppc64__)

  326.     uint64_t port_aux = (uint64_t)port;

  327. #else

  328.     uint32_t port_aux = (uint32_t)port;

  329. #endif

  330.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  331.     if (!CheckPort(myport)) {

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

  333.         return NULL;

  334.     } else {

  335.         JackGraphManager* manager = GetGraphManager();

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

  337.     }

  338. }

  339. 

  340. EXPORT const char* jack_port_short_name(const jack_port_t* port)

  341. {

  342. #ifdef __CLIENTDEBUG__

  343.     JackLibGlobals::CheckContext();

  344. #endif

  345. #if defined(__x86_64__) || defined(__ppc64__)

  346.     uint64_t port_aux = (uint64_t)port;

  347. #else

  348.     uint32_t port_aux = (uint32_t)port;

  349. #endif

  350.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  351.     if (!CheckPort(myport)) {

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

  353.         return NULL;

  354.     } else {

  355.         JackGraphManager* manager = GetGraphManager();

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

  357.     }

  358. }

  359. 

  360. EXPORT int jack_port_flags(const jack_port_t* port)

  361. {

  362. #ifdef __CLIENTDEBUG__

  363.     JackLibGlobals::CheckContext();

  364. #endif

  365. #if defined(__x86_64__) || defined(__ppc64__)

  366.     uint64_t port_aux = (uint64_t)port;

  367. #else

  368.     uint32_t port_aux = (uint32_t)port;

  369. #endif

  370.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  371.     if (!CheckPort(myport)) {

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

  373.         return -1;

  374.     } else {

  375.         JackGraphManager* manager = GetGraphManager();

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

  377.     }

  378. }

  379. 

  380. EXPORT const char* jack_port_type(const jack_port_t* port)

  381. {

  382. #ifdef __CLIENTDEBUG__

  383.     JackLibGlobals::CheckContext();

  384. #endif

  385.  #if defined(__x86_64__) || defined(__ppc64__)

  386.     uint64_t port_aux = (uint64_t)port;

  387. #else

  388.     uint32_t port_aux = (uint32_t)port;

  389. #endif

  390.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  391.    if (!CheckPort(myport)) {

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

  393.         return NULL;

  394.     } else {

  395.         JackGraphManager* manager = GetGraphManager();

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

  397.     }

  398. }

  399. 

  400. EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port)

  401. {

  402. #ifdef __CLIENTDEBUG__

  403.     JackLibGlobals::CheckContext();

  404. #endif

  405. #if defined(__x86_64__) || defined(__ppc64__)

  406.     uint64_t port_aux = (uint64_t)port;

  407. #else

  408.     uint32_t port_aux = (uint32_t)port;

  409. #endif

  410.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  411.     if (!CheckPort(myport)) {

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

  413.         return 0;

  414.     } else {

  415.         JackGraphManager* manager = GetGraphManager();

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

  417.     }

  418. }

  419. 

  420. EXPORT int jack_port_connected(const jack_port_t* port)

  421. {

  422. #ifdef __CLIENTDEBUG__

  423.     JackLibGlobals::CheckContext();

  424. #endif

  425. #if defined(__x86_64__) || defined(__ppc64__)

  426.     uint64_t port_aux = (uint64_t)port;

  427. #else

  428.     uint32_t port_aux = (uint32_t)port;

  429. #endif

  430.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  431.     if (!CheckPort(myport)) {

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

  433.         return -1;

  434.     } else {

  435.         WaitGraphChange();

  436.         JackGraphManager* manager = GetGraphManager();

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

  438.     }

  439. }

  440. 

  441. EXPORT int jack_port_connected_to(const jack_port_t* port, const char* port_name)

  442. {

  443. #ifdef __CLIENTDEBUG__

  444.     JackLibGlobals::CheckContext();

  445. #endif

  446. #if defined(__x86_64__) || defined(__ppc64__)

  447.     uint64_t port_aux = (uint64_t)port;

  448. #else

  449.     uint32_t port_aux = (uint32_t)port;

  450. #endif

  451.     jack_port_id_t src = (jack_port_id_t)port_aux;

  452.     if (!CheckPort(src)) {

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

  454.         return -1;

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

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

  457.         return -1;

  458.     } else {

  459.         WaitGraphChange();

  460.         JackGraphManager* manager = GetGraphManager();

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

  462.         if (dst == NO_PORT) {

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

  464.             return 0;

  465.         } else {

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

  467.         }

  468.     }

  469. }

  470. 

  471. EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)

  472. {

  473. #ifdef __CLIENTDEBUG__

  474.     JackLibGlobals::CheckContext();

  475. #endif

  476. #if defined(__x86_64__) || defined(__ppc64__)

  477.     uint64_t src_aux = (uint64_t)src;

  478. #else

  479.     uint32_t src_aux = (uint32_t)src;

  480. #endif

  481.     jack_port_id_t mysrc = (jack_port_id_t)src_aux;

  482.     if (!CheckPort(mysrc)) {

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

  484.         return -1;

  485.     }

  486. #if defined(__x86_64__) || defined(__ppc64__)

  487.     uint64_t dst_aux = (uint64_t)dst;

  488. #else

  489.     uint32_t dst_aux = (uint32_t)dst;

  490. #endif

  491.     jack_port_id_t mydst = (jack_port_id_t)dst_aux;

  492.     if (!CheckPort(mydst)) {

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

  494.         return -1;

  495.     }

  496.     JackGraphManager* manager = GetGraphManager();

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

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

  499.         return -1;

  500.     } else {

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

  502.     }

  503. }

  504. 

  505. EXPORT int jack_port_untie(jack_port_t* port)

  506. {

  507. #ifdef __CLIENTDEBUG__

  508.     JackLibGlobals::CheckContext();

  509. #endif

  510. #if defined(__x86_64__) || defined(__ppc64__)

  511.     uint64_t port_aux = (uint64_t)port;

  512. #else

  513.     uint32_t port_aux = (uint32_t)port;

  514. #endif

  515.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  516.     if (!CheckPort(myport)) {

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

  518.         return -1;

  519.     } else {

  520.         JackGraphManager* manager = GetGraphManager();

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

  522.     }

  523. }

  524. 

  525. EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)

  526. {

  527. #ifdef __CLIENTDEBUG__

  528.     JackLibGlobals::CheckContext();

  529. #endif

  530. #if defined(__x86_64__) || defined(__ppc64__)

  531.     uint64_t port_aux = (uint64_t)port;

  532. #else

  533.     uint32_t port_aux = (uint32_t)port;

  534. #endif

  535.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  536.     if (!CheckPort(myport)) {

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

  538.         return 0;

  539.     } else {

  540.         WaitGraphChange();

  541.         JackGraphManager* manager = GetGraphManager();

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

  543.     }

  544. }

  545. 

  546. EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)

  547. {

  548. #ifdef __CLIENTDEBUG__

  549.     JackLibGlobals::CheckContext();

  550. #endif

  551. #if defined(__x86_64__) || defined(__ppc64__)

  552.     uint64_t port_aux = (uint64_t)port;

  553. #else

  554.     uint32_t port_aux = (uint32_t)port;

  555. #endif

  556.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  557.     if (!CheckPort(myport)) {

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

  559.     } else {

  560.         JackGraphManager* manager = GetGraphManager();

  561.         if (manager)

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

  563.     }

  564. }

  565. 

  566. EXPORT int jack_recompute_total_latency(jack_client_t* ext_client, jack_port_t* port)

  567. {

  568. #ifdef __CLIENTDEBUG__

  569.     JackLibGlobals::CheckContext();

  570. #endif

  571. 

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

  573. #if defined(__x86_64__) || defined(__ppc64__)

  574.     uint64_t port_aux = (uint64_t)port;

  575. #else

  576.     uint32_t port_aux = (uint32_t)port;

  577. #endif

  578.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  579.     if (client == NULL) {

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

  581.         return -1;

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

  583.         jack_error("jack_recompute_total_latencies called with a NULL port");

  584.         return -1;

  585.     } else {

  586.         WaitGraphChange();

  587.         JackGraphManager* manager = GetGraphManager();

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

  589.     }

  590. }

  591. 

  592. EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)

  593. {

  594. #ifdef __CLIENTDEBUG__

  595.     JackLibGlobals::CheckContext();

  596. #endif

  597. 

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

  599.     if (client == NULL) {

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

  601.         return -1;

  602.     } else {

  603.         WaitGraphChange();

  604.         JackGraphManager* manager = GetGraphManager();

  605.         return (manager ? manager->ComputeTotalLatencies() : -1);

  606.     }

  607. }

  608. 

  609. /*

  610. This is unsafe if case of concurrent access, and should be "serialized" doing a server call.

  611. */

  612. 

  613. EXPORT int jack_port_set_name(jack_port_t* port, const char* name)

  614. {

  615. #ifdef __CLIENTDEBUG__

  616.     JackLibGlobals::CheckContext();

  617. #endif

  618. #if defined(__x86_64__) || defined(__ppc64__)

  619.     uint64_t port_aux = (uint64_t)port;

  620. #else

  621.     uint32_t port_aux = (uint32_t)port;

  622. #endif

  623.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  624.     if (!CheckPort(myport)) {

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

  626.         return -1;

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

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

  629.         return -1;

  630.     } else {

  631.         JackGraphManager* manager = GetGraphManager();

  632.         int refnum;

  633.         if (manager && ((refnum = manager->GetPort(myport)->GetRefNum()) > 0)) {

  634.             JackClient* client = JackGlobals::fClientTable[refnum];

  635.             assert(client);

  636.             return client->PortRename(myport, name);

  637.         } else {

  638.             return -1;

  639.         }

  640.     }

  641. }

  642. 

  643. EXPORT int jack_port_set_alias(jack_port_t* port, const char* name)

  644. {

  645. #ifdef __CLIENTDEBUG__

  646.     JackLibGlobals::CheckContext();

  647. #endif

  648. #if defined(__x86_64__) || defined(__ppc64__)

  649.     uint64_t port_aux = (uint64_t)port;

  650. #else

  651.     uint32_t port_aux = (uint32_t)port;

  652. #endif

  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. EXPORT int jack_port_unset_alias(jack_port_t* port, const char* name)

  667. {

  668. #ifdef __CLIENTDEBUG__

  669.     JackLibGlobals::CheckContext();

  670. #endif

  671. #if defined(__x86_64__) || defined(__ppc64__)

  672.     uint64_t port_aux = (uint64_t)port;

  673. #else

  674.     uint32_t port_aux = (uint32_t)port;

  675. #endif

  676.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  677.     if (!CheckPort(myport)) {

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

  679.         return -1;

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

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

  682.         return -1;

  683.     } else {

  684.         JackGraphManager* manager = GetGraphManager();

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

  686.     }

  687. }

  688. 

  689. EXPORT int jack_port_get_aliases(const jack_port_t* port, char* const aliases[2])

  690. {

  691. #ifdef __CLIENTDEBUG__

  692.     JackLibGlobals::CheckContext();

  693. #endif

  694. #if defined(__x86_64__) || defined(__ppc64__)

  695.     uint64_t port_aux = (uint64_t)port;

  696. #else

  697.     uint32_t port_aux = (uint32_t)port;

  698. #endif

  699.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  700.     if (!CheckPort(myport)) {

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

  702.         return -1;

  703.     } else {

  704.         JackGraphManager* manager = GetGraphManager();

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

  706.     }

  707. }

  708. 

  709. EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)

  710. {

  711. #ifdef __CLIENTDEBUG__

  712.     JackLibGlobals::CheckContext();

  713. #endif

  714. #if defined(__x86_64__) || defined(__ppc64__)

  715.     uint64_t port_aux = (uint64_t)port;

  716. #else

  717.     uint32_t port_aux = (uint32_t)port;

  718. #endif

  719.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  720.     if (!CheckPort(myport)) {

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

  722.         return -1;

  723.     } else {

  724.         JackGraphManager* manager = GetGraphManager();

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

  726.     }

  727. }

  728. 

  729. EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)

  730. {

  731. #ifdef __CLIENTDEBUG__

  732.     JackLibGlobals::CheckContext();

  733. #endif

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

  735.     if (client == NULL) {

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

  737.         return -1;

  738.     } else {

  739.         JackGraphManager* manager = GetGraphManager();

  740.         if (!manager)

  741.             return -1;

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

  743.         if (!CheckPort(myport)) {

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

  745.             return -1;

  746.         } else {

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

  748.         }

  749.     }

  750. }

  751. 

  752. EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)

  753. {

  754. #ifdef __CLIENTDEBUG__

  755.     JackLibGlobals::CheckContext();

  756. #endif

  757.  #if defined(__x86_64__) || defined(__ppc64__)

  758.     uint64_t port_aux = (uint64_t)port;

  759. #else

  760.     uint32_t port_aux = (uint32_t)port;

  761. #endif

  762.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  763.     if (!CheckPort(myport)) {

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

  765.         return -1;

  766.     } else {

  767.         JackGraphManager* manager = GetGraphManager();

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

  769.     }

  770. }

  771. 

  772. EXPORT int jack_port_monitoring_input(jack_port_t* port)

  773. {

  774. #ifdef __CLIENTDEBUG__

  775.     JackLibGlobals::CheckContext();

  776. #endif

  777. #if defined(__x86_64__) || defined(__ppc64__)

  778.     uint64_t port_aux = (uint64_t)port;

  779. #else

  780.     uint32_t port_aux = (uint32_t)port;

  781. #endif

  782.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  783.     if (!CheckPort(myport)) {

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

  785.         return -1;

  786.     } else {

  787.         JackGraphManager* manager = GetGraphManager();

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

  789.     }

  790. }

  791. 

  792. EXPORT int jack_is_realtime(jack_client_t* ext_client)

  793. {

  794. #ifdef __CLIENTDEBUG__

  795.     JackLibGlobals::CheckContext();

  796. #endif

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

  798.     if (client == NULL) {

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

  800.         return -1;

  801.     } else {

  802.         JackEngineControl* control = GetEngineControl();

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

  804.     }

  805. }

  806. 

  807. EXPORT void jack_on_shutdown(jack_client_t* ext_client, JackShutdownCallback callback, void* arg)

  808. {

  809. #ifdef __CLIENTDEBUG__

  810.     JackLibGlobals::CheckContext();

  811. #endif

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

  813.     if (client == NULL) {

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

  815.     } else {

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

  817.     }

  818. }

  819. 

  820. EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)

  821. {

  822. #ifdef __CLIENTDEBUG__

  823.     JackLibGlobals::CheckContext();

  824. #endif

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

  826.     if (client == NULL) {

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

  828.         return -1;

  829.     } else {

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

  831.     }

  832. }

  833. 

  834. EXPORT jack_nframes_t jack_thread_wait(jack_client_t* ext_client, int status)

  835. {

  836. #ifdef __CLIENTDEBUG__

  837.     JackLibGlobals::CheckContext();

  838. #endif

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

  840.     if (client == NULL) {

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

  842.         return 0;

  843.     } else {

  844.         return client->Wait(status);

  845.     }

  846. }

  847. 

  848. EXPORT jack_nframes_t jack_cycle_wait(jack_client_t* ext_client)

  849. {

  850. #ifdef __CLIENTDEBUG__

  851.     JackLibGlobals::CheckContext();

  852. #endif

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

  854.     if (client == NULL) {

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

  856.         return 0;

  857.     } else {

  858.         return client->CycleWait();

  859.     }

  860. }

  861. 

  862. EXPORT void jack_cycle_signal(jack_client_t* ext_client, int status)

  863. {

  864. #ifdef __CLIENTDEBUG__

  865.     JackLibGlobals::CheckContext();

  866. #endif

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

  868.     if (client == NULL) {

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

  870.     } else {

  871.         client->CycleSignal(status);

  872.     }

  873. }

  874. 

  875. EXPORT int jack_set_process_thread(jack_client_t* ext_client, JackThreadCallback fun, void *arg)

  876. {

  877. #ifdef __CLIENTDEBUG__

  878.     JackLibGlobals::CheckContext();

  879. #endif

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

  881.     if (client == NULL) {

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

  883.         return -1;

  884.     } else {

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

  886.     }

  887. }

  888. 

  889. EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)

  890. {

  891. #ifdef __CLIENTDEBUG__

  892.     JackLibGlobals::CheckContext();

  893. #endif

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

  895.     if (client == NULL) {

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

  897.         return -1;

  898.     } else {

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

  900.     }

  901. }

  902. 

  903. EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)

  904. {

  905. #ifdef __CLIENTDEBUG__

  906.     JackLibGlobals::CheckContext();

  907. #endif

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

  909.     if (client == NULL) {

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

  911.         return -1;

  912.     } else {

  913.         return client->SetFreeWheel(onoff);

  914.     }

  915. }

  916. 

  917. EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer_size)

  918. {

  919. #ifdef __CLIENTDEBUG__

  920.     JackLibGlobals::CheckContext();

  921. #endif

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

  923.     if (client == NULL) {

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

  925.         return -1;

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

  927.         return -1;

  928.     } else {

  929.         return client->SetBufferSize(buffer_size);

  930.     }

  931. }

  932. 

  933. EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)

  934. {

  935. #ifdef __CLIENTDEBUG__

  936.     JackLibGlobals::CheckContext();

  937. #endif

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

  939.     if (client == NULL) {

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

  941.         return -1;

  942.     } else {

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

  944.     }

  945. }

  946. 

  947. EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg)

  948. {

  949. #ifdef __CLIENTDEBUG__

  950.     JackLibGlobals::CheckContext();

  951. #endif

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

  953.     if (client == NULL) {

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

  955.         return -1;

  956.     } else {

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

  958.     }

  959. }

  960. 

  961. EXPORT int jack_set_client_registration_callback(jack_client_t* ext_client, JackClientRegistrationCallback registration_callback, void* arg)

  962. {

  963. #ifdef __CLIENTDEBUG__

  964.     JackLibGlobals::CheckContext();

  965. #endif

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

  967.     if (client == NULL) {

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

  969.         return -1;

  970.     } else {

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

  972.     }

  973. }

  974. 

  975. EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)

  976. {

  977. #ifdef __CLIENTDEBUG__

  978.     JackLibGlobals::CheckContext();

  979. #endif

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

  981.     if (client == NULL) {

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

  983.         return -1;

  984.     } else {

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

  986.     }

  987. }

  988. 

  989. EXPORT int jack_set_port_connect_callback(jack_client_t* ext_client, JackPortConnectCallback portconnect_callback, void* arg)

  990. {

  991. #ifdef __CLIENTDEBUG__

  992.     JackLibGlobals::CheckContext();

  993. #endif

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

  995.     if (client == NULL) {

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

  997.         return -1;

  998.     } else {

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

  1000.     }

  1001. }

  1002. 

  1003. EXPORT int jack_set_port_rename_callback(jack_client_t* ext_client, JackPortRenameCallback rename_callback, void* arg)

  1004. {

  1005. #ifdef __CLIENTDEBUG__

  1006.     JackLibGlobals::CheckContext();

  1007. #endif

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

  1009.     if (client == NULL) {

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

  1011.         return -1;

  1012.     } else {

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

  1014.     }

  1015. }

  1016. 

  1017. EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)

  1018. {

  1019. #ifdef __CLIENTDEBUG__

  1020.     JackLibGlobals::CheckContext();

  1021. #endif

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

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

  1024.     if (client == NULL) {

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

  1026.         return -1;

  1027.     } else {

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

  1029.     }

  1030. }

  1031. 

  1032. EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xrun_callback, void* arg)

  1033. {

  1034. #ifdef __CLIENTDEBUG__

  1035.     JackLibGlobals::CheckContext();

  1036. #endif

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

  1038.     if (client == NULL) {

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

  1040.         return -1;

  1041.     } else {

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

  1043.     }

  1044. }

  1045. 

  1046. EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg)

  1047. {

  1048. #ifdef __CLIENTDEBUG__

  1049.     JackLibGlobals::CheckContext();

  1050. #endif

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

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

  1053.     if (client == NULL) {

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

  1055.         return -1;

  1056.     } else {

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

  1058.     }

  1059. }

  1060. 

  1061. EXPORT int jack_activate(jack_client_t* ext_client)

  1062. {

  1063. #ifdef __CLIENTDEBUG__

  1064.     JackLibGlobals::CheckContext();

  1065. #endif

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

  1067.     if (client == NULL) {

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

  1069.         return -1;

  1070.     } else {

  1071.         return client->Activate();

  1072.     }

  1073. }

  1074. 

  1075. EXPORT int jack_deactivate(jack_client_t* ext_client)

  1076. {

  1077. #ifdef __CLIENTDEBUG__

  1078.     JackLibGlobals::CheckContext();

  1079. #endif

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

  1081.     if (client == NULL) {

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

  1083.         return -1;

  1084.     } else {

  1085.         return client->Deactivate();

  1086.     }

  1087. }

  1088. 

  1089. 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)

  1090. {

  1091. #ifdef __CLIENTDEBUG__

  1092.     JackLibGlobals::CheckContext();

  1093. #endif

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

  1095.     if (client == NULL) {

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

  1097.         return NULL;

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

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

  1100.         return NULL;

  1101.     } else {

  1102. #if defined(__x86_64__) || defined(__ppc64__)

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

  1104. #else

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

  1106. #endif

  1107.     }

  1108. }

  1109. 

  1110. EXPORT int jack_port_unregister(jack_client_t* ext_client, jack_port_t* port)

  1111. {

  1112. #ifdef __CLIENTDEBUG__

  1113.     JackLibGlobals::CheckContext();

  1114. #endif

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

  1116.     if (client == NULL) {

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

  1118.         return -1;

  1119.     }

  1120. #if defined(__x86_64__) || defined(__ppc64__)

  1121.     uint64_t port_aux = (uint64_t)port;

  1122. #else

  1123.     uint32_t port_aux = (uint32_t)port;

  1124. #endif

  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. EXPORT int jack_port_is_mine(const jack_client_t* ext_client, const jack_port_t* port)

  1134. {

  1135. #ifdef __CLIENTDEBUG__

  1136.     JackLibGlobals::CheckContext();

  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. #if defined(__x86_64__) || defined(__ppc64__)

  1144.     uint64_t port_aux = (uint64_t)port;

  1145. #else

  1146.     uint32_t port_aux = (uint32_t)port;

  1147. #endif

  1148.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1149.     if (!CheckPort(myport)) {

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

  1151.         return -1;

  1152.     }

  1153.     return client->PortIsMine(myport);

  1154. }

  1155. 

  1156. EXPORT const char** jack_port_get_connections(const jack_port_t* port)

  1157. {

  1158. #ifdef __CLIENTDEBUG__

  1159.     JackLibGlobals::CheckContext();

  1160. #endif

  1161. #if defined(__x86_64__) || defined(__ppc64__)

  1162.     uint64_t port_aux = (uint64_t)port;

  1163. #else

  1164.     uint32_t port_aux = (uint32_t)port;

  1165. #endif

  1166.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1167.     if (!CheckPort(myport)) {

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

  1169.         return NULL;

  1170.     } else {

  1171.         WaitGraphChange();

  1172.         JackGraphManager* manager = GetGraphManager();

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

  1174.     }

  1175. }

  1176. 

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

  1178. EXPORT const char** jack_port_get_all_connections(const jack_client_t* ext_client, const jack_port_t* port)

  1179. {

  1180. #ifdef __CLIENTDEBUG__

  1181.     JackLibGlobals::CheckContext();

  1182. #endif

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

  1184.     if (client == NULL) {

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

  1186.         return NULL;

  1187.     }

  1188. 

  1189. #if defined(__x86_64__) || defined(__ppc64__)

  1190.     uint64_t port_aux = (uint64_t)port;

  1191. #else

  1192.     uint32_t port_aux = (uint32_t)port;

  1193. #endif

  1194.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1195.     if (!CheckPort(myport)) {

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

  1197.         return NULL;

  1198.     } else {

  1199.         WaitGraphChange();

  1200.         JackGraphManager* manager = GetGraphManager();

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

  1202.     }

  1203. }

  1204. 

  1205. EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t* ext_client, jack_port_t* port)

  1206. {

  1207. #ifdef __CLIENTDEBUG__

  1208.     JackLibGlobals::CheckContext();

  1209. #endif

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

  1211.     if (client == NULL) {

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

  1213.         return 0;

  1214.     }

  1215. 

  1216. #if defined(__x86_64__) || defined(__ppc64__)

  1217.     uint64_t port_aux = (uint64_t)port;

  1218. #else

  1219.     uint32_t port_aux = (uint32_t)port;

  1220. #endif

  1221.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1222.     if (!CheckPort(myport)) {

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

  1224.         return 0;

  1225.     } else {

  1226.         WaitGraphChange();

  1227.         JackGraphManager* manager = GetGraphManager();

  1228.         if (manager) {

  1229.             manager->ComputeTotalLatency(myport);

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

  1231.         } else {

  1232.             return 0;

  1233.         }

  1234.     }

  1235. }

  1236. 

  1237. EXPORT int jack_connect(jack_client_t* ext_client, const char* src, const char* dst)

  1238. {

  1239. #ifdef __CLIENTDEBUG__

  1240.     JackLibGlobals::CheckContext();

  1241. #endif

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

  1243.     if (client == NULL) {

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

  1245.         return -1;

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

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

  1248.         return -1;

  1249.     } else {

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

  1251.     }

  1252. }

  1253. 

  1254. EXPORT int jack_disconnect(jack_client_t* ext_client, const char* src, const char* dst)

  1255. {

  1256. #ifdef __CLIENTDEBUG__

  1257.     JackLibGlobals::CheckContext();

  1258. #endif

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

  1260.     if (client == NULL) {

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

  1262.         return -1;

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

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

  1265.         return -1;

  1266.     } else {

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

  1268.     }

  1269. }

  1270. 

  1271. EXPORT int jack_port_disconnect(jack_client_t* ext_client, jack_port_t* src)

  1272. {

  1273. #ifdef __CLIENTDEBUG__

  1274.     JackLibGlobals::CheckContext();

  1275. #endif

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

  1277.     if (client == NULL) {

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

  1279.         return -1;

  1280.     }

  1281. #if defined(__x86_64__) || defined(__ppc64__)

  1282.     uint64_t port_aux = (uint64_t)src;

  1283. #else

  1284.     uint32_t port_aux = (uint32_t)src;

  1285. #endif

  1286.     jack_port_id_t myport = (jack_port_id_t)port_aux;

  1287.     if (!CheckPort(myport)) {

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

  1289.         return -1;

  1290.     }

  1291.     return client->PortDisconnect(myport);

  1292. }

  1293. 

  1294. EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t* ext_client)

  1295. {

  1296. #ifdef __CLIENTDEBUG__

  1297.     JackLibGlobals::CheckContext();

  1298. #endif

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

  1300.     if (client == NULL) {

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

  1302.         return 0;

  1303.     } else {

  1304.         JackEngineControl* control = GetEngineControl();

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

  1306.     }

  1307. }

  1308. 

  1309. EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t* ext_client)

  1310. {

  1311. #ifdef __CLIENTDEBUG__

  1312.     JackLibGlobals::CheckContext();

  1313. #endif

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

  1315.     if (client == NULL) {

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

  1317.         return 0;

  1318.     } else {

  1319.         JackEngineControl* control = GetEngineControl();

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

  1321.     }

  1322. }

  1323. 

  1324. EXPORT const char** jack_get_ports(jack_client_t* ext_client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)

  1325. {

  1326. #ifdef __CLIENTDEBUG__

  1327.     JackLibGlobals::CheckContext();

  1328. #endif

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

  1330.     if (client == NULL) {

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

  1332.         return NULL;

  1333.     }

  1334.     JackGraphManager* manager = GetGraphManager();

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

  1336. }

  1337. 

  1338. EXPORT jack_port_t* jack_port_by_name(jack_client_t* ext_client, const char* portname)

  1339. {

  1340. #ifdef __CLIENTDEBUG__

  1341.     JackLibGlobals::CheckContext();

  1342. #endif

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

  1344.     if (client == NULL) {

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

  1346.         return 0;

  1347.     }

  1348. 

  1349.     if (portname == NULL) {

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

  1351.         return NULL;

  1352.     } else {

  1353.         JackGraphManager* manager = GetGraphManager();

  1354.         if (!manager)

  1355.             return NULL;

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

  1357. #if defined(__x86_64__) || defined(__ppc64__)

  1358.         return (res == NO_PORT) ? NULL : (jack_port_t*)((uint64_t)res);

  1359. #else

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

  1361. #endif

  1362.     }

  1363. }

  1364. 

  1365. EXPORT jack_port_t* jack_port_by_id(jack_client_t* ext_client, jack_port_id_t id)

  1366. {

  1367. #ifdef __CLIENTDEBUG__

  1368.     JackLibGlobals::CheckContext();

  1369. #endif

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

  1371. #if defined(__x86_64__) || defined(__ppc64__)

  1372.     return (jack_port_t*)((uint64_t)id);

  1373. #else

  1374.     return (jack_port_t*)id;

  1375. #endif

  1376. }

  1377. 

  1378. EXPORT int jack_engine_takeover_timebase(jack_client_t* ext_client)

  1379. {

  1380. #ifdef __CLIENTDEBUG__

  1381.     JackLibGlobals::CheckContext();

  1382. #endif

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

  1384.     if (client == NULL) {

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

  1386.         return -1;

  1387.     } else {

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

  1389.         return 0;

  1390.     }

  1391. }

  1392. 

  1393. EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* ext_client)

  1394. {

  1395. #ifdef __CLIENTDEBUG__

  1396.     JackLibGlobals::CheckContext();

  1397. #endif

  1398.     JackTimer timer;

  1399.     JackEngineControl* control = GetEngineControl();

  1400.     if (control) {

  1401.         control->ReadFrameTime(&timer);

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

  1403.     } else {

  1404.         return 0;

  1405.     }

  1406. }

  1407. 

  1408. EXPORT jack_time_t jack_get_time()

  1409. {

  1410.     return GetMicroSeconds();

  1411. }

  1412. 

  1413. EXPORT jack_time_t jack_frames_to_time(const jack_client_t* ext_client, jack_nframes_t frames)

  1414. {

  1415. #ifdef __CLIENTDEBUG__

  1416.     JackLibGlobals::CheckContext();

  1417. #endif

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

  1419.     if (client == NULL) {

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

  1421.         return 0;

  1422.     } else {

  1423.         JackTimer timer;

  1424.         JackEngineControl* control = GetEngineControl();

  1425.         if (control) {

  1426.             control->ReadFrameTime(&timer);

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

  1428.         } else {

  1429.             return 0;

  1430.         }

  1431.     }

  1432. }

  1433. 

  1434. EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t* ext_client, jack_time_t time)

  1435. {

  1436. #ifdef __CLIENTDEBUG__

  1437.     JackLibGlobals::CheckContext();

  1438. #endif

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

  1440.     if (client == NULL) {

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

  1442.         return 0;

  1443.     } else {

  1444.         JackTimer timer;

  1445.         JackEngineControl* control = GetEngineControl();

  1446.         if (control) {

  1447.             control->ReadFrameTime(&timer);

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

  1449.         } else {

  1450.             return 0;

  1451.         }

  1452.     }

  1453. }

  1454. 

  1455. EXPORT jack_nframes_t jack_frame_time(const jack_client_t* ext_client)

  1456. {

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

  1458. }

  1459. 

  1460. EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t* ext_client)

  1461. {

  1462. #ifdef __CLIENTDEBUG__

  1463.     JackLibGlobals::CheckContext();

  1464. #endif

  1465.     JackTimer timer;

  1466.     JackEngineControl* control = GetEngineControl();

  1467.     if (control) {

  1468.         control->ReadFrameTime(&timer);

  1469.         return timer.CurFrame();

  1470.     } else {

  1471.         return 0;

  1472.     }

  1473. }

  1474. 

  1475. EXPORT float jack_cpu_load(jack_client_t* ext_client)

  1476. {

  1477. #ifdef __CLIENTDEBUG__

  1478.     JackLibGlobals::CheckContext();

  1479. #endif

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

  1481.     if (client == NULL) {

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

  1483.         return 0.0f;

  1484.     } else {

  1485.         JackEngineControl* control = GetEngineControl();

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

  1487.     }

  1488. }

  1489. 

  1490. EXPORT pthread_t jack_client_thread_id(jack_client_t* ext_client)

  1491. {

  1492. #ifdef __CLIENTDEBUG__

  1493.     JackLibGlobals::CheckContext();

  1494. #endif

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

  1496.     if (client == NULL) {

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

  1498.         return (pthread_t)NULL;

  1499.     } else {

  1500.         return client->GetThreadID();

  1501.     }

  1502. }

  1503. 

  1504. EXPORT char* jack_get_client_name(jack_client_t* ext_client)

  1505. {

  1506. #ifdef __CLIENTDEBUG__

  1507.     JackLibGlobals::CheckContext();

  1508. #endif

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

  1510.     if (client == NULL) {

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

  1512.         return NULL;

  1513.     } else {

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

  1515.     }

  1516. }

  1517. 

  1518. EXPORT int jack_client_name_size(void)

  1519. {

  1520.     return JACK_CLIENT_NAME_SIZE;

  1521. }

  1522. 

  1523. EXPORT int jack_port_name_size(void)

  1524. {

  1525.     return JACK_PORT_NAME_SIZE;

  1526. }

  1527. 

  1528. EXPORT int jack_port_type_size(void)

  1529. {

  1530.     return JACK_PORT_TYPE_SIZE;

  1531. }

  1532. 

  1533. // transport.h

  1534. EXPORT int jack_release_timebase(jack_client_t* ext_client)

  1535. {

  1536. #ifdef __CLIENTDEBUG__

  1537.     JackLibGlobals::CheckContext();

  1538. #endif

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

  1540.     if (client == NULL) {

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

  1542.         return -1;

  1543.     } else {

  1544.         return client->ReleaseTimebase();

  1545.     }

  1546. }

  1547. 

  1548. EXPORT int jack_set_sync_callback(jack_client_t* ext_client, JackSyncCallback sync_callback, void *arg)

  1549. {

  1550. #ifdef __CLIENTDEBUG__

  1551.     JackLibGlobals::CheckContext();

  1552. #endif

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

  1554.     if (client == NULL) {

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

  1556.         return -1;

  1557.     } else {

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

  1559.     }

  1560. }

  1561. 

  1562. EXPORT int jack_set_sync_timeout(jack_client_t* ext_client, jack_time_t timeout)

  1563. {

  1564. #ifdef __CLIENTDEBUG__

  1565.     JackLibGlobals::CheckContext();

  1566. #endif

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

  1568.     if (client == NULL) {

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

  1570.         return -1;

  1571.     } else {

  1572.         return client->SetSyncTimeout(timeout);

  1573.     }

  1574. }

  1575. 

  1576. EXPORT int jack_set_timebase_callback(jack_client_t* ext_client, int conditional, JackTimebaseCallback timebase_callback, void* arg)

  1577. {

  1578. #ifdef __CLIENTDEBUG__

  1579.     JackLibGlobals::CheckContext();

  1580. #endif

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

  1582.     if (client == NULL) {

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

  1584.         return -1;

  1585.     } else {

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

  1587.     }

  1588. }

  1589. 

  1590. EXPORT int jack_transport_locate(jack_client_t* ext_client, jack_nframes_t frame)

  1591. {

  1592. #ifdef __CLIENTDEBUG__

  1593.     JackLibGlobals::CheckContext();

  1594. #endif

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

  1596.     if (client == NULL) {

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

  1598.         return -1;

  1599.     } else {

  1600.         client->TransportLocate(frame);

  1601.         return 0;

  1602.     }

  1603. }

  1604. 

  1605. EXPORT jack_transport_state_t jack_transport_query(const jack_client_t* ext_client, jack_position_t* pos)

  1606. {

  1607. #ifdef __CLIENTDEBUG__

  1608.     JackLibGlobals::CheckContext();

  1609. #endif

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

  1611.     if (client == NULL) {

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

  1613.         return JackTransportStopped;

  1614.     } else {

  1615.         return client->TransportQuery(pos);

  1616.     }

  1617. }

  1618. 

  1619. EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t* ext_client)

  1620. {

  1621. #ifdef __CLIENTDEBUG__

  1622.     JackLibGlobals::CheckContext();

  1623. #endif

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

  1625.     if (client == NULL) {

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

  1627.         return 0;

  1628.     } else {

  1629.         return client->GetCurrentTransportFrame();

  1630.     }

  1631. }

  1632. 

  1633. EXPORT int jack_transport_reposition(jack_client_t* ext_client, jack_position_t* pos)

  1634. {

  1635. #ifdef __CLIENTDEBUG__

  1636.     JackLibGlobals::CheckContext();

  1637. #endif

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

  1639.     if (client == NULL) {

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

  1641.         return -1;

  1642.     } else {

  1643.         client->TransportReposition(pos);

  1644.         return 0;

  1645.     }

  1646. }

  1647. 

  1648. EXPORT void jack_transport_start(jack_client_t* ext_client)

  1649. {

  1650. #ifdef __CLIENTDEBUG__

  1651.     JackLibGlobals::CheckContext();

  1652. #endif

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

  1654.     if (client == NULL) {

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

  1656.     } else {

  1657.         client->TransportStart();

  1658.     }

  1659. }

  1660. 

  1661. EXPORT void jack_transport_stop(jack_client_t* ext_client)

  1662. {

  1663. #ifdef __CLIENTDEBUG__

  1664.     JackLibGlobals::CheckContext();

  1665. #endif

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

  1667.     if (client == NULL) {

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

  1669.     } else {

  1670.         client->TransportStop();

  1671.     }

  1672. }

  1673. 

  1674. // deprecated

  1675. EXPORT void jack_get_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)

  1676. {

  1677.     jack_error("jack_get_transport_info: deprecated");

  1678.     if (tinfo)

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

  1680. }

  1681. 

  1682. EXPORT void jack_set_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)

  1683. {

  1684.     jack_error("jack_set_transport_info: deprecated");

  1685.     if (tinfo)

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

  1687. }

  1688. 

  1689. // statistics.h

  1690. EXPORT float jack_get_max_delayed_usecs(jack_client_t* ext_client)

  1691. {

  1692. #ifdef __CLIENTDEBUG__

  1693.     JackLibGlobals::CheckContext();

  1694. #endif

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

  1696.     if (client == NULL) {

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

  1698.         return 0.f;

  1699.     } else {

  1700.         JackEngineControl* control = GetEngineControl();

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

  1702.     }

  1703.  }

  1704. 

  1705. EXPORT float jack_get_xrun_delayed_usecs(jack_client_t* ext_client)

  1706. {

  1707. #ifdef __CLIENTDEBUG__

  1708.     JackLibGlobals::CheckContext();

  1709. #endif

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

  1711.     if (client == NULL) {

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

  1713.         return 0.f;

  1714.     } else {

  1715.         JackEngineControl* control = GetEngineControl();

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

  1717.     }

  1718. }

  1719. 

  1720. EXPORT void jack_reset_max_delayed_usecs(jack_client_t* ext_client)

  1721. {

  1722. #ifdef __CLIENTDEBUG__

  1723.     JackLibGlobals::CheckContext();

  1724. #endif

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

  1726.     if (client == NULL) {

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

  1728.     } else {

  1729.         JackEngineControl* control = GetEngineControl();

  1730.         control->ResetXRun();

  1731.     }

  1732. }

  1733. 

  1734. // thread.h

  1735. EXPORT int jack_client_real_time_priority(jack_client_t* ext_client)

  1736. {

  1737. #ifdef __CLIENTDEBUG__

  1738.     JackLibGlobals::CheckContext();

  1739. #endif

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

  1741.     if (client == NULL) {

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

  1743.         return -1;

  1744.     } else {

  1745.         JackEngineControl* control = GetEngineControl();

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

  1747.     }

  1748. }

  1749. 

  1750. EXPORT int jack_client_max_real_time_priority(jack_client_t* ext_client)

  1751. {

  1752. #ifdef __CLIENTDEBUG__

  1753.     JackLibGlobals::CheckContext();

  1754. #endif

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

  1756.     if (client == NULL) {

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

  1758.         return -1;

  1759.     } else {

  1760.         JackEngineControl* control = GetEngineControl();

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

  1762.     }

  1763. } 

  1764.  

  1765. EXPORT int jack_acquire_real_time_scheduling(pthread_t thread, int priority)

  1766. {

  1767.     JackEngineControl* control = GetEngineControl();

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

  1769. }

  1770. 

  1771. EXPORT int jack_client_create_thread(jack_client_t* client,

  1772.                                      pthread_t *thread,

  1773.                                      int priority,

  1774.                                      int realtime,  	/* boolean */

  1775.                                      thread_routine routine,

  1776.                                      void *arg)

  1777. {

  1778.     return JackThread::StartImp(thread, priority, realtime, routine, arg);

  1779. }

  1780. 

  1781. EXPORT int jack_drop_real_time_scheduling(pthread_t thread)

  1782. {

  1783.     return JackThread::DropRealTimeImp(thread);

  1784. }

  1785. 

  1786. EXPORT int jack_client_stop_thread(jack_client_t* client, pthread_t thread)

  1787. {

  1788.     return JackThread::StopImp(thread);

  1789. }

  1790. 

  1791. EXPORT int jack_client_kill_thread(jack_client_t* client, pthread_t thread)

  1792. {

  1793.     return JackThread::KillImp(thread);

  1794. }

  1795. 

  1796. EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc)

  1797. {

  1798.     JackGlobals::fJackThreadCreator = jtc;

  1799. }

  1800. 

  1801. // intclient.h

  1802. EXPORT int jack_internal_client_new (const char *client_name,

  1803.                                      const char *load_name,

  1804.                                      const char *load_init)

  1805. {

  1806.     jack_error("jack_internal_client_new: deprecated");

  1807.     return -1;

  1808. }

  1809. 

  1810. EXPORT void jack_internal_client_close (const char *client_name)

  1811. {

  1812.     jack_error("jack_internal_client_close: deprecated");

  1813. }

  1814. 

  1815. EXPORT char* jack_get_internal_client_name(jack_client_t* ext_client, jack_intclient_t intclient)

  1816. {

  1817. #ifdef __CLIENTDEBUG__

  1818.     JackLibGlobals::CheckContext();

  1819. #endif

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

  1821.     if (client == NULL) {

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

  1823.         return NULL;

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

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

  1826.         return NULL;

  1827.     } else {

  1828.         return client->GetInternalClientName(intclient);

  1829.     }

  1830. }

  1831. 

  1832. EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t* ext_client, const char* client_name, jack_status_t* status)

  1833. {

  1834. #ifdef __CLIENTDEBUG__

  1835.     JackLibGlobals::CheckContext();

  1836. #endif

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

  1838.     if (client == NULL) {

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

  1840.         return 0;

  1841.     } else {

  1842.         jack_status_t my_status;

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

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

  1845.         *status = (jack_status_t)0;

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

  1847.     }

  1848. }

  1849. 

  1850. 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)

  1851. {

  1852. #ifdef __CLIENTDEBUG__

  1853.     JackLibGlobals::CheckContext();

  1854. #endif

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

  1856.     if (client == NULL) {

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

  1858.         return 0;

  1859.     } else {

  1860.         jack_varargs_t va;

  1861.         jack_status_t my_status;

  1862. 

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

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

  1865.         *status = (jack_status_t)0;

  1866. 

  1867.         /* validate parameters */

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

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

  1870.             *status = (jack_status_t)my_status1;

  1871.             return 0;

  1872.         }

  1873. 

  1874.         /* parse variable arguments */

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

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

  1877.     }

  1878. }

  1879. 

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

  1881. {

  1882.     va_list ap;

  1883.     va_start(ap, status);

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

  1885.     va_end(ap);

  1886.     return res;

  1887. }

  1888. 

  1889. EXPORT jack_status_t jack_internal_client_unload(jack_client_t* ext_client, jack_intclient_t intclient)

  1890. {

  1891. #ifdef __CLIENTDEBUG__

  1892.     JackLibGlobals::CheckContext();

  1893. #endif

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

  1895.     if (client == NULL) {

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

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

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

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

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

  1901.     } else {

  1902.         jack_status_t my_status;

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

  1904.         return my_status;

  1905.     }

  1906. }

  1907. 

  1908. EXPORT

  1909. void

  1910. jack_get_version(

  1911.     int *major_ptr,

  1912.     int *minor_ptr,

  1913.     int *micro_ptr,

  1914.     int *proto_ptr)

  1915. {

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

  1917.     *major_ptr = 0;

  1918.     *minor_ptr = 0;

  1919.     *micro_ptr = 0;

  1920.     *proto_ptr = 0;

  1921. }

  1922. 

  1923. EXPORT

  1924. const char *

  1925. jack_get_version_string()

  1926. {

  1927.     return VERSION;

  1928. }