Jack2  1.9.13
JackAPI.cpp
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 "JackPortType.h"
29 #include <math.h>
30 #define __STDC_FORMAT_MACROS 1
31 #include <inttypes.h>
32 
33 using namespace Jack;
34 
35 #ifdef __cplusplus
36 extern "C"
37 {
38 #endif
39 
40  typedef void (*print_function)(const char*);
41  typedef void *(*thread_routine)(void*);
42 
43  LIB_EXPORT
44  void
45  jack_get_version(
46  int *major_ptr,
47  int *minor_ptr,
48  int *micro_ptr,
49  int *proto_ptr);
50 
51  LIB_EXPORT
52  const char*
53  jack_get_version_string();
54 
55  jack_client_t * jack_client_new_aux(const char* client_name,
56  jack_options_t options,
57  jack_status_t *status);
58 
59  LIB_EXPORT jack_client_t * jack_client_open(const char* client_name,
60  jack_options_t options,
61  jack_status_t *status, ...);
62  LIB_EXPORT jack_client_t * jack_client_new(const char* client_name);
63  LIB_EXPORT int jack_client_name_size(void);
64  LIB_EXPORT char* jack_get_client_name(jack_client_t *client);
65  LIB_EXPORT int jack_internal_client_new(const char* client_name,
66  const char* load_name,
67  const char* load_init);
68  LIB_EXPORT void jack_internal_client_close(const char* client_name);
69  LIB_EXPORT int jack_is_realtime(jack_client_t *client);
70  LIB_EXPORT void jack_on_shutdown(jack_client_t *client,
71  JackShutdownCallback shutdown_callback, void *arg);
72  LIB_EXPORT void jack_on_info_shutdown(jack_client_t *client,
73  JackInfoShutdownCallback shutdown_callback, void *arg);
74  LIB_EXPORT int jack_set_process_callback(jack_client_t *client,
75  JackProcessCallback process_callback,
76  void *arg);
77  LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t *client, int status);
78 
79  // new
80  LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t*);
81  LIB_EXPORT void jack_cycle_signal(jack_client_t*, int status);
82  LIB_EXPORT int jack_set_process_thread(jack_client_t* client, JackThreadCallback fun, void *arg);
83 
84  LIB_EXPORT int jack_set_thread_init_callback(jack_client_t *client,
85  JackThreadInitCallback thread_init_callback,
86  void *arg);
87  LIB_EXPORT int jack_set_freewheel_callback(jack_client_t *client,
88  JackFreewheelCallback freewheel_callback,
89  void *arg);
90  LIB_EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);
91  LIB_EXPORT int jack_set_buffer_size(jack_client_t *client, jack_nframes_t nframes);
92  LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t *client,
93  JackBufferSizeCallback bufsize_callback,
94  void *arg);
95  LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t *client,
96  JackSampleRateCallback srate_callback,
97  void *arg);
98  LIB_EXPORT int jack_set_client_registration_callback(jack_client_t *,
99  JackClientRegistrationCallback
100  registration_callback, void *arg);
101  LIB_EXPORT int jack_set_port_registration_callback(jack_client_t *,
102  JackPortRegistrationCallback
103  registration_callback, void *arg);
104  LIB_EXPORT int jack_set_port_connect_callback(jack_client_t *,
105  JackPortConnectCallback
106  connect_callback, void *arg);
107  LIB_EXPORT int jack_set_port_rename_callback(jack_client_t *,
108  JackPortRenameCallback
109  rename_callback, void *arg);
110  LIB_EXPORT int jack_set_graph_order_callback(jack_client_t *,
111  JackGraphOrderCallback graph_callback,
112  void *);
113  LIB_EXPORT int jack_set_xrun_callback(jack_client_t *,
114  JackXRunCallback xrun_callback, void *arg);
115  LIB_EXPORT int jack_set_latency_callback(jack_client_t *client,
116  JackLatencyCallback latency_callback, void *arg);
117 
118  LIB_EXPORT int jack_activate(jack_client_t *client);
119  LIB_EXPORT int jack_deactivate(jack_client_t *client);
120  LIB_EXPORT jack_port_t * jack_port_register(jack_client_t *client,
121  const char* port_name,
122  const char* port_type,
123  unsigned long flags,
124  unsigned long buffer_size);
125  LIB_EXPORT int jack_port_unregister(jack_client_t *, jack_port_t *);
126  LIB_EXPORT void * jack_port_get_buffer(jack_port_t *, jack_nframes_t);
127  LIB_EXPORT jack_uuid_t jack_port_uuid(const jack_port_t*);
128  LIB_EXPORT const char* jack_port_name(const jack_port_t *port);
129  LIB_EXPORT const char* jack_port_short_name(const jack_port_t *port);
130  LIB_EXPORT int jack_port_flags(const jack_port_t *port);
131  LIB_EXPORT const char* jack_port_type(const jack_port_t *port);
132  LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port);
133  LIB_EXPORT int jack_port_is_mine(const jack_client_t *, const jack_port_t *port);
134  LIB_EXPORT int jack_port_connected(const jack_port_t *port);
135  LIB_EXPORT int jack_port_connected_to(const jack_port_t *port,
136  const char* port_name);
137  LIB_EXPORT const char* * jack_port_get_connections(const jack_port_t *port);
138  LIB_EXPORT const char* * jack_port_get_all_connections(const jack_client_t *client,
139  const jack_port_t *port);
140  LIB_EXPORT int jack_port_tie(jack_port_t *src, jack_port_t *dst);
141  LIB_EXPORT int jack_port_untie(jack_port_t *port);
142 
143  // Old latency API
144  LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t *port);
145  LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t *,
146  jack_port_t *port);
147  LIB_EXPORT void jack_port_set_latency(jack_port_t *, jack_nframes_t);
148  LIB_EXPORT int jack_recompute_total_latency(jack_client_t*, jack_port_t* port);
149 
150  // New latency API
151  LIB_EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);
152  LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range);
153  LIB_EXPORT int jack_recompute_total_latencies(jack_client_t*);
154 
155  LIB_EXPORT int jack_port_set_name(jack_port_t *port, const char* port_name);
156  LIB_EXPORT int jack_port_rename(jack_client_t *client, jack_port_t *port, const char* port_name);
157  LIB_EXPORT int jack_port_set_alias(jack_port_t *port, const char* alias);
158  LIB_EXPORT int jack_port_unset_alias(jack_port_t *port, const char* alias);
159  LIB_EXPORT int jack_port_get_aliases(const jack_port_t *port, char* const aliases[2]);
160  LIB_EXPORT int jack_port_request_monitor(jack_port_t *port, int onoff);
161  LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t *client,
162  const char* port_name, int onoff);
163  LIB_EXPORT int jack_port_ensure_monitor(jack_port_t *port, int onoff);
164  LIB_EXPORT int jack_port_monitoring_input(jack_port_t *port);
165  LIB_EXPORT int jack_connect(jack_client_t *,
166  const char* source_port,
167  const char* destination_port);
168  LIB_EXPORT int jack_disconnect(jack_client_t *,
169  const char* source_port,
170  const char* destination_port);
171  LIB_EXPORT int jack_port_disconnect(jack_client_t *, jack_port_t *);
172  LIB_EXPORT int jack_port_name_size(void);
173  LIB_EXPORT int jack_port_type_size(void);
174  LIB_EXPORT size_t jack_port_type_get_buffer_size(jack_client_t *client, const char* port_type);
175  LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t *);
176  LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t *);
177  LIB_EXPORT const char* * jack_get_ports(jack_client_t *,
178  const char* port_name_pattern,
179  const char* type_name_pattern,
180  unsigned long flags);
181  LIB_EXPORT jack_port_t * jack_port_by_name(jack_client_t *, const char* port_name);
182  LIB_EXPORT jack_port_t * jack_port_by_id(jack_client_t *client,
183  jack_port_id_t port_id);
184  LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t *);
185  LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t *);
186  LIB_EXPORT jack_time_t jack_get_time();
187  LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t usecs);
188  LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames);
189  LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t *);
190  LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t *client);
191  LIB_EXPORT int jack_get_cycle_times(const jack_client_t *client,
192  jack_nframes_t *current_frames,
193  jack_time_t *current_usecs,
194  jack_time_t *next_usecs,
195  float *period_usecs);
196  LIB_EXPORT float jack_cpu_load(jack_client_t *client);
197  LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t *);
198  LIB_EXPORT void jack_set_error_function(print_function);
199  LIB_EXPORT void jack_set_info_function(print_function);
200 
201  LIB_EXPORT float jack_get_max_delayed_usecs(jack_client_t *client);
202  LIB_EXPORT float jack_get_xrun_delayed_usecs(jack_client_t *client);
203  LIB_EXPORT void jack_reset_max_delayed_usecs(jack_client_t *client);
204 
205  LIB_EXPORT int jack_release_timebase(jack_client_t *client);
206  LIB_EXPORT int jack_set_sync_callback(jack_client_t *client,
207  JackSyncCallback sync_callback,
208  void *arg);
209  LIB_EXPORT int jack_set_sync_timeout(jack_client_t *client,
210  jack_time_t timeout);
211  LIB_EXPORT int jack_set_timebase_callback(jack_client_t *client,
212  int conditional,
213  JackTimebaseCallback timebase_callback,
214  void *arg);
215  LIB_EXPORT int jack_transport_locate(jack_client_t *client,
216  jack_nframes_t frame);
217  LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t *client,
218  jack_position_t *pos);
219  LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t *client);
220  LIB_EXPORT int jack_transport_reposition(jack_client_t *client,
221  const jack_position_t *pos);
222  LIB_EXPORT void jack_transport_start(jack_client_t *client);
223  LIB_EXPORT void jack_transport_stop(jack_client_t *client);
224  LIB_EXPORT void jack_get_transport_info(jack_client_t *client,
225  jack_transport_info_t *tinfo);
226  LIB_EXPORT void jack_set_transport_info(jack_client_t *client,
227  jack_transport_info_t *tinfo);
228 
229  LIB_EXPORT int jack_client_real_time_priority(jack_client_t*);
230  LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t*);
231  LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority);
232  LIB_EXPORT int jack_client_create_thread(jack_client_t* client,
233  jack_native_thread_t *thread,
234  int priority,
235  int realtime, // boolean
236  thread_routine routine,
237  void *arg);
238  LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread);
239 
240  LIB_EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread);
241  LIB_EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread);
242 #ifndef WIN32
243  LIB_EXPORT void jack_set_thread_creator(jack_thread_creator_t jtc);
244 #endif
245  LIB_EXPORT char * jack_get_internal_client_name(jack_client_t *client,
246  jack_intclient_t intclient);
247  LIB_EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t *client,
248  const char* client_name,
249  jack_status_t *status);
250  LIB_EXPORT jack_intclient_t jack_internal_client_load(jack_client_t *client,
251  const char* client_name,
252  jack_options_t options,
253  jack_status_t *status, ...);
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  LIB_EXPORT jack_uuid_t jack_client_uuid_generate();
271  LIB_EXPORT jack_uuid_t jack_port_uuid_generate(uint32_t port_id);
272  LIB_EXPORT uint32_t jack_uuid_to_index(jack_uuid_t);
273  LIB_EXPORT int jack_uuid_compare(jack_uuid_t, jack_uuid_t);
274  LIB_EXPORT void jack_uuid_copy(jack_uuid_t* dst, jack_uuid_t src);
275  LIB_EXPORT void jack_uuid_clear(jack_uuid_t*);
276  LIB_EXPORT int jack_uuid_parse(const char* buf, jack_uuid_t*);
277  LIB_EXPORT void jack_uuid_unparse(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);
278  LIB_EXPORT int jack_uuid_empty(jack_uuid_t);
279 
280 #ifdef __cplusplus
281 }
282 #endif
283 
284 static inline bool CheckPort(jack_port_id_t port_index)
285 {
286  return (port_index > 0 && port_index < PORT_NUM_MAX);
287 }
288 
289 static inline bool CheckBufferSize(jack_nframes_t buffer_size)
290 {
291  return (buffer_size >= 1 && buffer_size <= BUFFER_SIZE_MAX);
292 }
293 
294 static inline void WaitGraphChange()
295 {
296  /*
297  TLS key that is set only in RT thread, so never waits for pending
298  graph change in RT context (just read the current graph state).
299  */
300 
301  if (jack_tls_get(JackGlobals::fRealTimeThread) == NULL) {
302  JackGraphManager* manager = GetGraphManager();
303  JackEngineControl* control = GetEngineControl();
304  assert(manager);
305  assert(control);
306  if (manager->IsPendingChange()) {
307  jack_log("WaitGraphChange...");
308  JackSleep(int(control->fPeriodUsecs * 1.1f));
309  }
310  }
311 }
312 
313 LIB_EXPORT void jack_set_error_function(print_function func)
314 {
315  jack_error_callback = (func == NULL) ? &default_jack_error_callback : func;
316 }
317 
318 LIB_EXPORT void jack_set_info_function(print_function func)
319 {
320  jack_info_callback = (func == NULL) ? &default_jack_info_callback : func;
321 }
322 
323 LIB_EXPORT jack_client_t* jack_client_new(const char* client_name)
324 {
325  JackGlobals::CheckContext("jack_client_new");
326 
327  try {
328  assert(JackGlobals::fOpenMutex);
329  JackGlobals::fOpenMutex->Lock();
330  jack_error("jack_client_new: deprecated");
331  int options = JackUseExactName;
332  if (getenv("JACK_START_SERVER") == NULL) {
333  options |= JackNoStartServer;
334  }
335  jack_client_t* res = jack_client_new_aux(client_name, (jack_options_t)options, NULL);
336  JackGlobals::fOpenMutex->Unlock();
337  return res;
338  } catch (std::bad_alloc& e) {
339  jack_error("Memory allocation error...");
340  return NULL;
341  } catch (...) {
342  jack_error("Unknown error...");
343  return NULL;
344  }
345 }
346 
347 LIB_EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)
348 {
349  JackGlobals::CheckContext("jack_port_get_buffer");
350 
351  uintptr_t port_aux = (uintptr_t)port;
352  jack_port_id_t myport = (jack_port_id_t)port_aux;
353  if (!CheckPort(myport)) {
354  jack_error("jack_port_get_buffer called with an incorrect port %ld", myport);
355  return NULL;
356  } else {
357  JackGraphManager* manager = GetGraphManager();
358  return (manager ? manager->GetBuffer(myport, frames) : NULL);
359  }
360 }
361 
362 LIB_EXPORT jack_uuid_t jack_port_uuid(const jack_port_t* port)
363 {
364  JackGlobals::CheckContext("jack_port_uuid");
365 
366  uintptr_t port_aux = (uintptr_t)port;
367  jack_port_id_t myport = (jack_port_id_t)port_aux;
368  if (!CheckPort(myport)) {
369  jack_error("jack_port_uuid called with an incorrect port %ld", myport);
370  return 0;
371  } else {
372  return jack_port_uuid_generate(myport);
373  }
374 }
375 
376 LIB_EXPORT const char* jack_port_name(const jack_port_t* port)
377 {
378  JackGlobals::CheckContext("jack_port_name");
379 
380  uintptr_t port_aux = (uintptr_t)port;
381  jack_port_id_t myport = (jack_port_id_t)port_aux;
382  if (!CheckPort(myport)) {
383  jack_error("jack_port_name called with an incorrect port %ld", myport);
384  return NULL;
385  } else {
386  JackGraphManager* manager = GetGraphManager();
387  return (manager ? manager->GetPort(myport)->GetName() : NULL);
388  }
389 }
390 
391 LIB_EXPORT const char* jack_port_short_name(const jack_port_t* port)
392 {
393  JackGlobals::CheckContext("jack_port_short_name");
394 
395  uintptr_t port_aux = (uintptr_t)port;
396  jack_port_id_t myport = (jack_port_id_t)port_aux;
397  if (!CheckPort(myport)) {
398  jack_error("jack_port_short_name called with an incorrect port %ld", myport);
399  return NULL;
400  } else {
401  JackGraphManager* manager = GetGraphManager();
402  return (manager ? manager->GetPort(myport)->GetShortName() : NULL);
403  }
404 }
405 
406 LIB_EXPORT int jack_port_flags(const jack_port_t* port)
407 {
408  JackGlobals::CheckContext("jack_port_flags");
409 
410  uintptr_t port_aux = (uintptr_t)port;
411  jack_port_id_t myport = (jack_port_id_t)port_aux;
412  if (!CheckPort(myport)) {
413  jack_error("jack_port_flags called with an incorrect port %ld", myport);
414  return -1;
415  } else {
416  JackGraphManager* manager = GetGraphManager();
417  return (manager ? manager->GetPort(myport)->GetFlags() : -1);
418  }
419 }
420 
421 LIB_EXPORT const char* jack_port_type(const jack_port_t* port)
422 {
423  JackGlobals::CheckContext("jack_port_type");
424 
425  uintptr_t port_aux = (uintptr_t)port;
426  jack_port_id_t myport = (jack_port_id_t)port_aux;
427  if (!CheckPort(myport)) {
428  jack_error("jack_port_flags called an incorrect port %ld", myport);
429  return NULL;
430  } else {
431  JackGraphManager* manager = GetGraphManager();
432  return (manager ? manager->GetPort(myport)->GetType() : NULL);
433  }
434 }
435 
436 LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port)
437 {
438  JackGlobals::CheckContext("jack_port_type_id");
439 
440  uintptr_t port_aux = (uintptr_t)port;
441  jack_port_id_t myport = (jack_port_id_t)port_aux;
442  if (!CheckPort(myport)) {
443  jack_error("jack_port_type_id called an incorrect port %ld", myport);
444  return 0;
445  } else {
446  JackGraphManager* manager = GetGraphManager();
447  return (manager ? GetPortTypeId(manager->GetPort(myport)->GetType()) : 0);
448  }
449 }
450 
451 LIB_EXPORT int jack_port_connected(const jack_port_t* port)
452 {
453  JackGlobals::CheckContext("jack_port_connected");
454 
455  uintptr_t port_aux = (uintptr_t)port;
456  jack_port_id_t myport = (jack_port_id_t)port_aux;
457  if (!CheckPort(myport)) {
458  jack_error("jack_port_connected called with an incorrect port %ld", myport);
459  return -1;
460  } else {
461  WaitGraphChange();
462  JackGraphManager* manager = GetGraphManager();
463  return (manager ? manager->GetConnectionsNum(myport) : -1);
464  }
465 }
466 
467 LIB_EXPORT int jack_port_connected_to(const jack_port_t* port, const char* port_name)
468 {
469  JackGlobals::CheckContext("jack_port_connected_to");
470 
471  uintptr_t port_aux = (uintptr_t)port;
472  jack_port_id_t src = (jack_port_id_t)port_aux;
473  if (!CheckPort(src)) {
474  jack_error("jack_port_connected_to called with an incorrect port %ld", src);
475  return -1;
476  } else if (port_name == NULL) {
477  jack_error("jack_port_connected_to called with a NULL port name");
478  return -1;
479  } else {
480  WaitGraphChange();
481  JackGraphManager* manager = GetGraphManager();
482  jack_port_id_t dst = (manager ? manager->GetPort(port_name) : NO_PORT);
483  if (dst == NO_PORT) {
484  jack_error("Unknown destination port port_name = %s", port_name);
485  return 0;
486  } else {
487  return manager->IsConnected(src, dst);
488  }
489  }
490 }
491 
492 LIB_EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)
493 {
494  JackGlobals::CheckContext("jack_port_tie");
495 
496  uintptr_t src_aux = (uintptr_t)src;
497  jack_port_id_t mysrc = (jack_port_id_t)src_aux;
498  if (!CheckPort(mysrc)) {
499  jack_error("jack_port_tie called with a NULL src port");
500  return -1;
501  }
502  uintptr_t dst_aux = (uintptr_t)dst;
503  jack_port_id_t mydst = (jack_port_id_t)dst_aux;
504  if (!CheckPort(mydst)) {
505  jack_error("jack_port_tie called with a NULL dst port");
506  return -1;
507  }
508  JackGraphManager* manager = GetGraphManager();
509  if (manager && manager->GetPort(mysrc)->GetRefNum() != manager->GetPort(mydst)->GetRefNum()) {
510  jack_error("jack_port_tie called with ports not belonging to the same client");
511  return -1;
512  } else {
513  return manager->GetPort(mydst)->Tie(mysrc);
514  }
515 }
516 
517 LIB_EXPORT int jack_port_untie(jack_port_t* port)
518 {
519  JackGlobals::CheckContext("jack_port_untie");
520 
521  uintptr_t port_aux = (uintptr_t)port;
522  jack_port_id_t myport = (jack_port_id_t)port_aux;
523  if (!CheckPort(myport)) {
524  jack_error("jack_port_untie called with an incorrect port %ld", myport);
525  return -1;
526  } else {
527  JackGraphManager* manager = GetGraphManager();
528  return (manager ? manager->GetPort(myport)->UnTie() : -1);
529  }
530 }
531 
532 LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)
533 {
534  JackGlobals::CheckContext("jack_port_get_latency");
535 
536  uintptr_t port_aux = (uintptr_t)port;
537  jack_port_id_t myport = (jack_port_id_t)port_aux;
538  if (!CheckPort(myport)) {
539  jack_error("jack_port_get_latency called with an incorrect port %ld", myport);
540  return 0;
541  } else {
542  WaitGraphChange();
543  JackGraphManager* manager = GetGraphManager();
544  return (manager ? manager->GetPort(myport)->GetLatency() : 0);
545  }
546 }
547 
548 LIB_EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
549 {
550  JackGlobals::CheckContext("jack_port_set_latency");
551 
552  uintptr_t port_aux = (uintptr_t)port;
553  jack_port_id_t myport = (jack_port_id_t)port_aux;
554  if (!CheckPort(myport)) {
555  jack_error("jack_port_set_latency called with an incorrect port %ld", myport);
556  } else {
557  JackGraphManager* manager = GetGraphManager();
558  if (manager)
559  manager->GetPort(myport)->SetLatency(frames);
560  }
561 }
562 
563 LIB_EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
564 {
565  JackGlobals::CheckContext("jack_port_get_latency_range");
566 
567  uintptr_t port_aux = (uintptr_t)port;
568  jack_port_id_t myport = (jack_port_id_t)port_aux;
569  if (!CheckPort(myport)) {
570  jack_error("jack_port_get_latency_range called with an incorrect port %ld", myport);
571  } else {
572  WaitGraphChange();
573  JackGraphManager* manager = GetGraphManager();
574  if (manager)
575  manager->GetPort(myport)->GetLatencyRange(mode, range);
576  }
577 }
578 
579 LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
580 {
581  JackGlobals::CheckContext("jack_port_set_latency_range");
582 
583  uintptr_t port_aux = (uintptr_t)port;
584  jack_port_id_t myport = (jack_port_id_t)port_aux;
585  if (!CheckPort(myport)) {
586  jack_error("jack_port_set_latency_range called with an incorrect port %ld", myport);
587  } else {
588  WaitGraphChange();
589  JackGraphManager* manager = GetGraphManager();
590  if (manager)
591  manager->GetPort(myport)->SetLatencyRange(mode, range);
592  }
593 }
594 
595 LIB_EXPORT int jack_recompute_total_latency(jack_client_t* ext_client, jack_port_t* port)
596 {
597  JackGlobals::CheckContext("jack_recompute_total_latency");
598 
599 
600  JackClient* client = (JackClient*)ext_client;
601  uintptr_t port_aux = (uintptr_t)port;
602  jack_port_id_t myport = (jack_port_id_t)port_aux;
603  if (client == NULL) {
604  jack_error("jack_recompute_total_latency called with a NULL client");
605  return -1;
606  } else if (!CheckPort(myport)) {
607  jack_error("jack_recompute_total_latency called with a NULL port");
608  return -1;
609  } else {
610  WaitGraphChange();
611  JackGraphManager* manager = GetGraphManager();
612  return (manager ? manager->ComputeTotalLatency(myport) : -1);
613  }
614 }
615 
616 LIB_EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)
617 {
618  JackGlobals::CheckContext("jack_recompute_total_latencies");
619 
620  JackClient* client = (JackClient*)ext_client;
621  if (client == NULL) {
622  jack_error("jack_recompute_total_latencies called with a NULL client");
623  return -1;
624  } else {
625  return client->ComputeTotalLatencies();
626  }
627 }
628 
629 LIB_EXPORT int jack_port_set_name(jack_port_t* port, const char* name)
630 {
631  JackGlobals::CheckContext("jack_port_set_name");
632  jack_error("jack_port_set_name: deprecated");
633 
634  // Find a valid client
635  jack_client_t* client = NULL;
636  for (int i = 0; i < CLIENT_NUM; i++) {
637  if ((client = (jack_client_t*)JackGlobals::fClientTable[i])) {
638  break;
639  }
640  }
641 
642  return (client) ? jack_port_rename(client, port, name) : -1;
643 }
644 
645 LIB_EXPORT int jack_port_rename(jack_client_t* ext_client, jack_port_t* port, const char* name)
646 {
647  JackGlobals::CheckContext("jack_port_rename");
648 
649  JackClient* client = (JackClient*)ext_client;
650  uintptr_t port_aux = (uintptr_t)port;
651  jack_port_id_t myport = (jack_port_id_t)port_aux;
652  if (client == NULL) {
653  jack_error("jack_port_rename called with a NULL client");
654  return -1;
655  } else if (!CheckPort(myport)) {
656  jack_error("jack_port_rename called with an incorrect port %ld", myport);
657  return -1;
658  } else if (name == NULL) {
659  jack_error("jack_port_rename called with a NULL port name");
660  return -1;
661  } else {
662  return client->PortRename(myport, name);
663  }
664 }
665 
666 LIB_EXPORT int jack_port_set_alias(jack_port_t* port, const char* name)
667 {
668  JackGlobals::CheckContext("jack_port_set_alias");
669 
670  uintptr_t port_aux = (uintptr_t)port;
671  jack_port_id_t myport = (jack_port_id_t)port_aux;
672  if (!CheckPort(myport)) {
673  jack_error("jack_port_set_alias called with an incorrect port %ld", myport);
674  return -1;
675  } else if (name == NULL) {
676  jack_error("jack_port_set_alias called with a NULL port name");
677  return -1;
678  } else {
679  JackGraphManager* manager = GetGraphManager();
680  return (manager ? manager->GetPort(myport)->SetAlias(name) : -1);
681  }
682 }
683 
684 LIB_EXPORT int jack_port_unset_alias(jack_port_t* port, const char* name)
685 {
686  JackGlobals::CheckContext("jack_port_unset_alias");
687 
688  uintptr_t port_aux = (uintptr_t)port;
689  jack_port_id_t myport = (jack_port_id_t)port_aux;
690  if (!CheckPort(myport)) {
691  jack_error("jack_port_unset_alias called with an incorrect port %ld", myport);
692  return -1;
693  } else if (name == NULL) {
694  jack_error("jack_port_unset_alias called with a NULL port name");
695  return -1;
696  } else {
697  JackGraphManager* manager = GetGraphManager();
698  return (manager ? manager->GetPort(myport)->UnsetAlias(name) : -1);
699  }
700 }
701 
702 LIB_EXPORT int jack_port_get_aliases(const jack_port_t* port, char* const aliases[2])
703 {
704  JackGlobals::CheckContext("jack_port_get_aliases");
705 
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_get_aliases called with an incorrect port %ld", myport);
710  return -1;
711  } else {
712  JackGraphManager* manager = GetGraphManager();
713  return (manager ? manager->GetPort(myport)->GetAliases(aliases) : -1);
714  }
715 }
716 
717 LIB_EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)
718 {
719  JackGlobals::CheckContext("jack_port_request_monitor");
720 
721  uintptr_t port_aux = (uintptr_t)port;
722  jack_port_id_t myport = (jack_port_id_t)port_aux;
723  if (!CheckPort(myport)) {
724  jack_error("jack_port_request_monitor called with an incorrect port %ld", myport);
725  return -1;
726  } else {
727  JackGraphManager* manager = GetGraphManager();
728  return (manager ? manager->RequestMonitor(myport, onoff) : -1);
729  }
730 }
731 
732 LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)
733 {
734  JackGlobals::CheckContext("jack_port_request_monitor_by_name");
735 
736  JackClient* client = (JackClient*)ext_client;
737  if (client == NULL) {
738  jack_error("jack_port_request_monitor_by_name called with a NULL client");
739  return -1;
740  } else {
741  JackGraphManager* manager = GetGraphManager();
742  if (!manager)
743  return -1;
744  jack_port_id_t myport = manager->GetPort(port_name);
745  if (!CheckPort(myport)) {
746  jack_error("jack_port_request_monitor_by_name called with an incorrect port %s", port_name);
747  return -1;
748  } else {
749  return manager->RequestMonitor(myport, onoff);
750  }
751  }
752 }
753 
754 LIB_EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)
755 {
756  JackGlobals::CheckContext("jack_port_ensure_monitor");
757 
758  uintptr_t port_aux = (uintptr_t)port;
759  jack_port_id_t myport = (jack_port_id_t)port_aux;
760  if (!CheckPort(myport)) {
761  jack_error("jack_port_ensure_monitor called with an incorrect port %ld", myport);
762  return -1;
763  } else {
764  JackGraphManager* manager = GetGraphManager();
765  return (manager ? manager->GetPort(myport)->EnsureMonitor(onoff) : -1);
766  }
767 }
768 
769 LIB_EXPORT int jack_port_monitoring_input(jack_port_t* port)
770 {
771  JackGlobals::CheckContext("jack_port_monitoring_input");
772 
773  uintptr_t port_aux = (uintptr_t)port;
774  jack_port_id_t myport = (jack_port_id_t)port_aux;
775  if (!CheckPort(myport)) {
776  jack_error("jack_port_monitoring_input called with an incorrect port %ld", myport);
777  return -1;
778  } else {
779  JackGraphManager* manager = GetGraphManager();
780  return (manager ? manager->GetPort(myport)->MonitoringInput() : -1);
781  }
782 }
783 
784 LIB_EXPORT int jack_is_realtime(jack_client_t* ext_client)
785 {
786  JackGlobals::CheckContext("jack_is_realtime");
787 
788  JackClient* client = (JackClient*)ext_client;
789  if (client == NULL) {
790  jack_error("jack_is_realtime called with a NULL client");
791  return -1;
792  } else {
793  JackEngineControl* control = GetEngineControl();
794  return (control ? control->fRealTime : -1);
795  }
796 }
797 
798 LIB_EXPORT void jack_on_shutdown(jack_client_t* ext_client, JackShutdownCallback callback, void* arg)
799 {
800  JackGlobals::CheckContext("jack_on_shutdown");
801 
802  JackClient* client = (JackClient*)ext_client;
803  if (client == NULL) {
804  jack_error("jack_on_shutdown called with a NULL client");
805  } else {
806  client->OnShutdown(callback, arg);
807  }
808 }
809 
810 LIB_EXPORT void jack_on_info_shutdown(jack_client_t* ext_client, JackInfoShutdownCallback callback, void* arg)
811 {
812  JackGlobals::CheckContext("jack_on_info_shutdown");
813 
814  JackClient* client = (JackClient*)ext_client;
815  if (client == NULL) {
816  jack_error("jack_on_info_shutdown called with a NULL client");
817  } else {
818  client->OnInfoShutdown(callback, arg);
819  }
820 }
821 
822 LIB_EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)
823 {
824  JackGlobals::CheckContext("jack_set_process_callback");
825 
826  JackClient* client = (JackClient*)ext_client;
827  if (client == NULL) {
828  jack_error("jack_set_process_callback called with a NULL client");
829  return -1;
830  } else {
831  return client->SetProcessCallback(callback, arg);
832  }
833 }
834 
835 LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t* ext_client, int status)
836 {
837  JackGlobals::CheckContext("jack_thread_wait");
838 
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  jack_error("jack_thread_wait: deprecated, use jack_cycle_wait/jack_cycle_signal");
845  return 0;
846  }
847 }
848 
849 LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t* ext_client)
850 {
851  JackGlobals::CheckContext("jack_cycle_wait");
852 
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 LIB_EXPORT void jack_cycle_signal(jack_client_t* ext_client, int status)
863 {
864  JackGlobals::CheckContext("jack_cycle_signal");
865 
866  JackClient* client = (JackClient*)ext_client;
867  if (client == NULL) {
868  jack_error("jack_cycle_signal called with a NULL client");
869  } else {
870  client->CycleSignal(status);
871  }
872 }
873 
874 LIB_EXPORT int jack_set_process_thread(jack_client_t* ext_client, JackThreadCallback fun, void *arg)
875 {
876  JackGlobals::CheckContext("jack_set_process_thread");
877 
878  JackClient* client = (JackClient*)ext_client;
879  if (client == NULL) {
880  jack_error("jack_set_process_thread called with a NULL client");
881  return -1;
882  } else {
883  return client->SetProcessThread(fun, arg);
884  }
885 }
886 
887 LIB_EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)
888 {
889  JackGlobals::CheckContext("jack_set_freewheel_callback");
890 
891  JackClient* client = (JackClient*)ext_client;
892  if (client == NULL) {
893  jack_error("jack_set_freewheel_callback called with a NULL client");
894  return -1;
895  } else {
896  return client->SetFreewheelCallback(freewheel_callback, arg);
897  }
898 }
899 
900 LIB_EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)
901 {
902  JackGlobals::CheckContext("jack_set_freewheel");
903 
904  JackClient* client = (JackClient*)ext_client;
905  if (client == NULL) {
906  jack_error("jack_set_freewheel called with a NULL client");
907  return -1;
908  } else {
909  return client->SetFreeWheel(onoff);
910  }
911 }
912 
913 LIB_EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer_size)
914 {
915  JackGlobals::CheckContext("jack_set_buffer_size");
916 
917  JackClient* client = (JackClient*)ext_client;
918  if (client == NULL) {
919  jack_error("jack_set_buffer_size called with a NULL client");
920  return -1;
921  } else if (!CheckBufferSize(buffer_size)) {
922  return -1;
923  } else {
924  return client->SetBufferSize(buffer_size);
925  }
926 }
927 
928 LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)
929 {
930  JackGlobals::CheckContext("jack_set_buffer_size_callback");
931 
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  JackGlobals::CheckContext("jack_set_sample_rate_callback");
944 
945  JackClient* client = (JackClient*)ext_client;
946  if (client == NULL) {
947  jack_error("jack_set_sample_rate_callback called with a NULL client");
948  return -1;
949  } else {
950  return client->SetSampleRateCallback(srate_callback, arg);
951  }
952 }
953 
954 LIB_EXPORT int jack_set_client_registration_callback(jack_client_t* ext_client, JackClientRegistrationCallback registration_callback, void* arg)
955 {
956  JackGlobals::CheckContext("jack_set_client_registration_callback");
957 
958  JackClient* client = (JackClient*)ext_client;
959  if (client == NULL) {
960  jack_error("jack_set_client_registration_callback called with a NULL client");
961  return -1;
962  } else {
963  return client->SetClientRegistrationCallback(registration_callback, arg);
964  }
965 }
966 
967 LIB_EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)
968 {
969  JackGlobals::CheckContext("jack_set_port_registration_callback");
970 
971  JackClient* client = (JackClient*)ext_client;
972  if (client == NULL) {
973  jack_error("jack_set_port_registration_callback called with a NULL client");
974  return -1;
975  } else {
976  return client->SetPortRegistrationCallback(registration_callback, arg);
977  }
978 }
979 
980 LIB_EXPORT int jack_set_port_connect_callback(jack_client_t* ext_client, JackPortConnectCallback portconnect_callback, void* arg)
981 {
982  JackGlobals::CheckContext("jack_set_port_connect_callback");
983 
984  JackClient* client = (JackClient*)ext_client;
985  if (client == NULL) {
986  jack_error("jack_set_port_connect_callback called with a NULL client");
987  return -1;
988  } else {
989  return client->SetPortConnectCallback(portconnect_callback, arg);
990  }
991 }
992 
993 LIB_EXPORT int jack_set_port_rename_callback(jack_client_t* ext_client, JackPortRenameCallback rename_callback, void* arg)
994 {
995  JackGlobals::CheckContext("jack_set_port_rename_callback");
996 
997  JackClient* client = (JackClient*)ext_client;
998  if (client == NULL) {
999  jack_error("jack_set_port_rename_callback called with a NULL client");
1000  return -1;
1001  } else {
1002  return client->SetPortRenameCallback(rename_callback, arg);
1003  }
1004 }
1005 
1006 LIB_EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)
1007 {
1008  JackGlobals::CheckContext("jack_set_graph_order_callback");
1009 
1010  JackClient* client = (JackClient*)ext_client;
1011  jack_log("jack_set_graph_order_callback ext_client %x client %x ", ext_client, client);
1012  if (client == NULL) {
1013  jack_error("jack_set_graph_order_callback called with a NULL client");
1014  return -1;
1015  } else {
1016  return client->SetGraphOrderCallback(graph_callback, arg);
1017  }
1018 }
1019 
1020 LIB_EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xrun_callback, void* arg)
1021 {
1022  JackGlobals::CheckContext("jack_set_xrun_callback");
1023 
1024  JackClient* client = (JackClient*)ext_client;
1025  if (client == NULL) {
1026  jack_error("jack_set_xrun_callback called with a NULL client");
1027  return -1;
1028  } else {
1029  return client->SetXRunCallback(xrun_callback, arg);
1030  }
1031 }
1032 
1033 LIB_EXPORT int jack_set_latency_callback(jack_client_t* ext_client, JackLatencyCallback latency_callback, void *arg)
1034 {
1035  JackGlobals::CheckContext("jack_set_latency_callback");
1036 
1037  JackClient* client = (JackClient*)ext_client;
1038  if (client == NULL) {
1039  jack_error("jack_set_latency_callback called with a NULL client");
1040  return -1;
1041  } else {
1042  return client->SetLatencyCallback(latency_callback, arg);
1043  }
1044 }
1045 
1046 LIB_EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg)
1047 {
1048  JackGlobals::CheckContext("jack_set_thread_init_callback");
1049 
1050  JackClient* client = (JackClient*)ext_client;
1051  jack_log("jack_set_thread_init_callback ext_client %x client %x ", ext_client, client);
1052  if (client == NULL) {
1053  jack_error("jack_set_thread_init_callback called with a NULL client");
1054  return -1;
1055  } else {
1056  return client->SetInitCallback(init_callback, arg);
1057  }
1058 }
1059 
1060 LIB_EXPORT int jack_activate(jack_client_t* ext_client)
1061 {
1062  JackGlobals::CheckContext("jack_activate");
1063 
1064  JackClient* client = (JackClient*)ext_client;
1065  if (client == NULL) {
1066  jack_error("jack_activate called with a NULL client");
1067  return -1;
1068  } else {
1069  return client->Activate();
1070  }
1071 }
1072 
1073 LIB_EXPORT int jack_deactivate(jack_client_t* ext_client)
1074 {
1075  JackGlobals::CheckContext("jack_deactivate");
1076 
1077  JackClient* client = (JackClient*)ext_client;
1078  if (client == NULL) {
1079  jack_error("jack_deactivate called with a NULL client");
1080  return -1;
1081  } else {
1082  return client->Deactivate();
1083  }
1084 }
1085 
1086 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)
1087 {
1088  JackGlobals::CheckContext("jack_port_register");
1089 
1090  JackClient* client = (JackClient*)ext_client;
1091  if (client == NULL) {
1092  jack_error("jack_port_register called with a NULL client");
1093  return NULL;
1094  } else if ((port_name == NULL) || (port_type == NULL)) {
1095  jack_error("jack_port_register called with a NULL port name or a NULL port_type");
1096  return NULL;
1097  } else {
1098  return (jack_port_t *)((uintptr_t)client->PortRegister(port_name, port_type, flags, buffer_size));
1099  }
1100 }
1101 
1102 LIB_EXPORT int jack_port_unregister(jack_client_t* ext_client, jack_port_t* port)
1103 {
1104  JackGlobals::CheckContext("jack_port_unregister");
1105 
1106  JackClient* client = (JackClient*)ext_client;
1107  if (client == NULL) {
1108  jack_error("jack_port_unregister called with a NULL client");
1109  return -1;
1110  }
1111  uintptr_t port_aux = (uintptr_t)port;
1112  jack_port_id_t myport = (jack_port_id_t)port_aux;
1113  if (!CheckPort(myport)) {
1114  jack_error("jack_port_unregister called with an incorrect port %ld", myport);
1115  return -1;
1116  }
1117  return client->PortUnRegister(myport);
1118 }
1119 
1120 LIB_EXPORT int jack_port_is_mine(const jack_client_t* ext_client, const jack_port_t* port)
1121 {
1122  JackGlobals::CheckContext("jack_port_is_mine");
1123 
1124  JackClient* client = (JackClient*)ext_client;
1125  if (client == NULL) {
1126  jack_error("jack_port_is_mine called with a NULL client");
1127  return -1;
1128  }
1129  uintptr_t port_aux = (uintptr_t)port;
1130  jack_port_id_t myport = (jack_port_id_t)port_aux;
1131  if (!CheckPort(myport)) {
1132  jack_error("jack_port_is_mine called with an incorrect port %ld", myport);
1133  return -1;
1134  }
1135  return client->PortIsMine(myport);
1136 }
1137 
1138 LIB_EXPORT const char** jack_port_get_connections(const jack_port_t* port)
1139 {
1140  JackGlobals::CheckContext("jack_port_get_connections");
1141 
1142  uintptr_t port_aux = (uintptr_t)port;
1143  jack_port_id_t myport = (jack_port_id_t)port_aux;
1144  if (!CheckPort(myport)) {
1145  jack_error("jack_port_get_connections called with an incorrect port %ld", myport);
1146  return NULL;
1147  } else {
1148  WaitGraphChange();
1149  JackGraphManager* manager = GetGraphManager();
1150  return (manager ? manager->GetConnections(myport) : NULL);
1151  }
1152 }
1153 
1154 // Calling client does not need to "own" the port
1155 LIB_EXPORT const char** jack_port_get_all_connections(const jack_client_t* ext_client, const jack_port_t* port)
1156 {
1157  JackGlobals::CheckContext("jack_port_get_all_connections");
1158 
1159  JackClient* client = (JackClient*)ext_client;
1160  if (client == NULL) {
1161  jack_error("jack_port_get_all_connections called with a NULL client");
1162  return NULL;
1163  }
1164 
1165  uintptr_t port_aux = (uintptr_t)port;
1166  jack_port_id_t myport = (jack_port_id_t)port_aux;
1167  if (!CheckPort(myport)) {
1168  jack_error("jack_port_get_all_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 LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t* ext_client, jack_port_t* port)
1178 {
1179  JackGlobals::CheckContext("jack_port_get_total_latency");
1180 
1181  JackClient* client = (JackClient*)ext_client;
1182  if (client == NULL) {
1183  jack_error("jack_port_get_total_latency called with a NULL client");
1184  return 0;
1185  }
1186 
1187  uintptr_t port_aux = (uintptr_t)port;
1188  jack_port_id_t myport = (jack_port_id_t)port_aux;
1189  if (!CheckPort(myport)) {
1190  jack_error("jack_port_get_total_latency called with an incorrect port %ld", myport);
1191  return 0;
1192  } else {
1193  WaitGraphChange();
1194  JackGraphManager* manager = GetGraphManager();
1195  if (manager) {
1196  manager->ComputeTotalLatency(myport);
1197  return manager->GetPort(myport)->GetTotalLatency();
1198  } else {
1199  return 0;
1200  }
1201  }
1202 }
1203 
1204 LIB_EXPORT int jack_connect(jack_client_t* ext_client, const char* src, const char* dst)
1205 {
1206  JackGlobals::CheckContext("jack_connect");
1207 
1208  JackClient* client = (JackClient*)ext_client;
1209  if (client == NULL) {
1210  jack_error("jack_connect called with a NULL client");
1211  return -1;
1212  } else if ((src == NULL) || (dst == NULL)) {
1213  jack_error("jack_connect called with a NULL port name");
1214  return -1;
1215  } else {
1216  return client->PortConnect(src, dst);
1217  }
1218 }
1219 
1220 LIB_EXPORT int jack_disconnect(jack_client_t* ext_client, const char* src, const char* dst)
1221 {
1222  JackGlobals::CheckContext("jack_disconnect");
1223 
1224  JackClient* client = (JackClient*)ext_client;
1225  if (client == NULL) {
1226  jack_error("jack_disconnect called with a NULL client");
1227  return -1;
1228  } else if ((src == NULL) || (dst == NULL)) {
1229  jack_error("jack_disconnect called with a NULL port name");
1230  return -1;
1231  } else {
1232  return client->PortDisconnect(src, dst);
1233  }
1234 }
1235 
1236 LIB_EXPORT int jack_port_disconnect(jack_client_t* ext_client, jack_port_t* src)
1237 {
1238  JackGlobals::CheckContext("jack_port_disconnect");
1239 
1240  JackClient* client = (JackClient*)ext_client;
1241  if (client == NULL) {
1242  jack_error("jack_port_disconnect called with a NULL client");
1243  return -1;
1244  }
1245  uintptr_t port_aux = (uintptr_t)src;
1246  jack_port_id_t myport = (jack_port_id_t)port_aux;
1247  if (!CheckPort(myport)) {
1248  jack_error("jack_port_disconnect called with an incorrect port %ld", myport);
1249  return -1;
1250  }
1251  return client->PortDisconnect(myport);
1252 }
1253 
1254 LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t* ext_client)
1255 {
1256  JackGlobals::CheckContext("jack_get_sample_rate");
1257 
1258  JackClient* client = (JackClient*)ext_client;
1259  if (client == NULL) {
1260  jack_error("jack_get_sample_rate called with a NULL client");
1261  return 0;
1262  } else {
1263  JackEngineControl* control = GetEngineControl();
1264  return (control ? control->fSampleRate : 0);
1265  }
1266 }
1267 
1268 LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t* ext_client)
1269 {
1270  JackGlobals::CheckContext("jack_get_buffer_size");
1271 
1272  JackClient* client = (JackClient*)ext_client;
1273  if (client == NULL) {
1274  jack_error("jack_get_buffer_size called with a NULL client");
1275  return 0;
1276  } else {
1277  JackEngineControl* control = GetEngineControl();
1278  return (control ? control->fBufferSize : 0);
1279  }
1280 }
1281 
1282 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)
1283 {
1284  JackGlobals::CheckContext("jack_get_ports");
1285 
1286  JackClient* client = (JackClient*)ext_client;
1287  if (client == NULL) {
1288  jack_error("jack_get_ports called with a NULL client");
1289  return NULL;
1290  }
1291  JackGraphManager* manager = GetGraphManager();
1292  return (manager ? manager->GetPorts(port_name_pattern, type_name_pattern, flags) : NULL);
1293 }
1294 
1295 LIB_EXPORT jack_port_t* jack_port_by_name(jack_client_t* ext_client, const char* portname)
1296 {
1297  JackGlobals::CheckContext("jack_port_by_name");
1298 
1299  JackClient* client = (JackClient*)ext_client;
1300  if (client == NULL) {
1301  jack_error("jack_port_by_name called with a NULL client");
1302  return NULL;
1303  }
1304 
1305  if (portname == NULL) {
1306  jack_error("jack_port_by_name called with a NULL port name");
1307  return NULL;
1308  }
1309 
1310  JackGraphManager* manager = GetGraphManager();
1311  if (manager) {
1312  int res = manager->GetPort(portname); // returns a port index at least > 1
1313  return (res == NO_PORT) ? NULL : (jack_port_t*)((uintptr_t)res);
1314  } else {
1315  return NULL;
1316  }
1317 }
1318 
1319 LIB_EXPORT jack_port_t* jack_port_by_id(jack_client_t* ext_client, jack_port_id_t id)
1320 {
1321  JackGlobals::CheckContext("jack_port_by_id");
1322 
1323  /* jack_port_t* type is actually the port index */
1324  return (jack_port_t*)((uintptr_t)id);
1325 }
1326 
1327 LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t* ext_client)
1328 {
1329  JackGlobals::CheckContext("jack_engine_takeover_timebase");
1330 
1331  JackClient* client = (JackClient*)ext_client;
1332  if (client == NULL) {
1333  jack_error("jack_engine_takeover_timebase called with a NULL client");
1334  return -1;
1335  } else {
1336  jack_error("jack_engine_takeover_timebase: deprecated\n");
1337  return 0;
1338  }
1339 }
1340 
1341 LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* ext_client)
1342 {
1343  JackGlobals::CheckContext("jack_frames_since_cycle_start");
1344 
1345  JackTimer timer;
1346  JackEngineControl* control = GetEngineControl();
1347  if (control) {
1348  control->ReadFrameTime(&timer);
1349  return timer.FramesSinceCycleStart(GetMicroSeconds(), control->fSampleRate);
1350  } else {
1351  return 0;
1352  }
1353 }
1354 
1355 LIB_EXPORT jack_time_t jack_get_time()
1356 {
1357  JackGlobals::CheckContext("jack_get_time");
1358 
1359  return GetMicroSeconds();
1360 }
1361 
1362 LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t* ext_client, jack_nframes_t frames)
1363 {
1364  JackGlobals::CheckContext("jack_frames_to_time");
1365 
1366  JackClient* client = (JackClient*)ext_client;
1367  if (client == NULL) {
1368  jack_error("jack_frames_to_time called with a NULL client");
1369  return 0;
1370  } else {
1371  JackTimer timer;
1372  JackEngineControl* control = GetEngineControl();
1373  if (control) {
1374  control->ReadFrameTime(&timer);
1375  return timer.Frames2Time(frames, control->fBufferSize);
1376  } else {
1377  return 0;
1378  }
1379  }
1380 }
1381 
1382 LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t* ext_client, jack_time_t usecs)
1383 {
1384  JackGlobals::CheckContext("jack_time_to_frames");
1385 
1386  JackClient* client = (JackClient*)ext_client;
1387  if (client == NULL) {
1388  jack_error("jack_time_to_frames called with a NULL client");
1389  return 0;
1390  } else {
1391  JackTimer timer;
1392  JackEngineControl* control = GetEngineControl();
1393  if (control) {
1394  control->ReadFrameTime(&timer);
1395  return timer.Time2Frames(usecs, control->fBufferSize);
1396  } else {
1397  return 0;
1398  }
1399  }
1400 }
1401 
1402 LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t* ext_client)
1403 {
1404  JackGlobals::CheckContext("jack_frame_time");
1405 
1406  return jack_time_to_frames(ext_client, GetMicroSeconds());
1407 }
1408 
1409 LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t* ext_client)
1410 {
1411  JackGlobals::CheckContext("jack_last_frame_time");
1412 
1413  JackEngineControl* control = GetEngineControl();
1414  return (control) ? control->fFrameTimer.ReadCurrentState()->CurFrame() : 0;
1415 }
1416 
1417 LIB_EXPORT int jack_get_cycle_times(const jack_client_t *client,
1418  jack_nframes_t *current_frames,
1419  jack_time_t *current_usecs,
1420  jack_time_t *next_usecs,
1421  float *period_usecs)
1422 {
1423  JackGlobals::CheckContext("jack_get_cycle_times");
1424 
1425  JackEngineControl* control = GetEngineControl();
1426  if (control) {
1427  JackTimer timer;
1428  control->ReadFrameTime(&timer);
1429  return timer.GetCycleTimes(current_frames, current_usecs, next_usecs, period_usecs);
1430  } else {
1431  return -1;
1432  }
1433 }
1434 
1435 LIB_EXPORT float jack_cpu_load(jack_client_t* ext_client)
1436 {
1437  JackGlobals::CheckContext("jack_cpu_load");
1438 
1439  JackClient* client = (JackClient*)ext_client;
1440  if (client == NULL) {
1441  jack_error("jack_cpu_load called with a NULL client");
1442  return 0.0f;
1443  } else {
1444  JackEngineControl* control = GetEngineControl();
1445  return (control ? control->fCPULoad : 0.0f);
1446  }
1447 }
1448 
1449 LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t* ext_client)
1450 {
1451  JackGlobals::CheckContext("jack_client_thread_id");
1452 
1453  JackClient* client = (JackClient*)ext_client;
1454  if (client == NULL) {
1455  jack_error("jack_client_thread_id called with a NULL client");
1456  return (jack_native_thread_t)NULL;
1457  } else {
1458  return client->GetThreadID();
1459  }
1460 }
1461 
1462 LIB_EXPORT char* jack_get_client_name(jack_client_t* ext_client)
1463 {
1464  JackGlobals::CheckContext("jack_get_client_name");
1465 
1466  JackClient* client = (JackClient*)ext_client;
1467  if (client == NULL) {
1468  jack_error("jack_get_client_name called with a NULL client");
1469  return NULL;
1470  } else {
1471  return client->GetClientControl()->fName;
1472  }
1473 }
1474 
1475 LIB_EXPORT int jack_client_name_size(void)
1476 {
1477  return JACK_CLIENT_NAME_SIZE+1;
1478 }
1479 
1480 LIB_EXPORT int jack_port_name_size(void)
1481 {
1482  return REAL_JACK_PORT_NAME_SIZE+1;
1483 }
1484 
1485 LIB_EXPORT int jack_port_type_size(void)
1486 {
1487  return JACK_PORT_TYPE_SIZE;
1488 }
1489 
1490 LIB_EXPORT size_t jack_port_type_get_buffer_size(jack_client_t* ext_client, const char* port_type)
1491 {
1492  JackGlobals::CheckContext("jack_port_type_get_buffer_size");
1493 
1494  JackClient* client = (JackClient*)ext_client;
1495  if (client == NULL) {
1496  jack_error("jack_port_type_get_buffer_size called with a NULL client");
1497  return 0;
1498  } else {
1499  jack_port_type_id_t port_id = GetPortTypeId(port_type);
1500  if (port_id == PORT_TYPES_MAX) {
1501  jack_error("jack_port_type_get_buffer_size called with an unknown port type = %s", port_type);
1502  return 0;
1503  } else {
1504  return GetPortType(port_id)->size();
1505  }
1506  }
1507 }
1508 
1509 // transport.h
1510 LIB_EXPORT int jack_release_timebase(jack_client_t* ext_client)
1511 {
1512  JackGlobals::CheckContext("jack_release_timebase");
1513 
1514  JackClient* client = (JackClient*)ext_client;
1515  if (client == NULL) {
1516  jack_error("jack_release_timebase called with a NULL client");
1517  return -1;
1518  } else {
1519  return client->ReleaseTimebase();
1520  }
1521 }
1522 
1523 LIB_EXPORT int jack_set_sync_callback(jack_client_t* ext_client, JackSyncCallback sync_callback, void *arg)
1524 {
1525  JackGlobals::CheckContext("jack_set_sync_callback");
1526 
1527  JackClient* client = (JackClient*)ext_client;
1528  if (client == NULL) {
1529  jack_error("jack_set_sync_callback called with a NULL client");
1530  return -1;
1531  } else {
1532  return client->SetSyncCallback(sync_callback, arg);
1533  }
1534 }
1535 
1536 LIB_EXPORT int jack_set_sync_timeout(jack_client_t* ext_client, jack_time_t timeout)
1537 {
1538  JackGlobals::CheckContext("jack_set_sync_timeout");
1539 
1540  JackClient* client = (JackClient*)ext_client;
1541  if (client == NULL) {
1542  jack_error("jack_set_sync_timeout called with a NULL client");
1543  return -1;
1544  } else {
1545  return client->SetSyncTimeout(timeout);
1546  }
1547 }
1548 
1549 LIB_EXPORT int jack_set_timebase_callback(jack_client_t* ext_client, int conditional, JackTimebaseCallback timebase_callback, void* arg)
1550 {
1551  JackGlobals::CheckContext("jack_set_timebase_callback");
1552 
1553  JackClient* client = (JackClient*)ext_client;
1554  if (client == NULL) {
1555  jack_error("jack_set_timebase_callback called with a NULL client");
1556  return -1;
1557  } else {
1558  return client->SetTimebaseCallback(conditional, timebase_callback, arg);
1559  }
1560 }
1561 
1562 LIB_EXPORT int jack_transport_locate(jack_client_t* ext_client, jack_nframes_t frame)
1563 {
1564  JackGlobals::CheckContext("jack_transport_locate");
1565 
1566  JackClient* client = (JackClient*)ext_client;
1567  if (client == NULL) {
1568  jack_error("jack_transport_locate called with a NULL client");
1569  return -1;
1570  } else {
1571  client->TransportLocate(frame);
1572  return 0;
1573  }
1574 }
1575 
1576 LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t* ext_client, jack_position_t* pos)
1577 {
1578  JackGlobals::CheckContext("jack_transport_query");
1579 
1580  JackClient* client = (JackClient*)ext_client;
1581  if (client == NULL) {
1582  jack_error("jack_transport_query called with a NULL client");
1583  return JackTransportStopped;
1584  } else {
1585  return client->TransportQuery(pos);
1586  }
1587 }
1588 
1589 LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t* ext_client)
1590 {
1591  JackGlobals::CheckContext("jack_get_current_transport_frame");
1592 
1593  JackClient* client = (JackClient*)ext_client;
1594  if (client == NULL) {
1595  jack_error("jack_get_current_transport_frame called with a NULL client");
1596  return 0;
1597  } else {
1598  return client->GetCurrentTransportFrame();
1599  }
1600 }
1601 
1602 LIB_EXPORT int jack_transport_reposition(jack_client_t* ext_client, const jack_position_t* pos)
1603 {
1604  JackGlobals::CheckContext("jack_transport_reposition");
1605 
1606  JackClient* client = (JackClient*)ext_client;
1607  if (client == NULL) {
1608  jack_error("jack_transport_reposition called with a NULL client");
1609  return -1;
1610  } else {
1611  client->TransportReposition(pos);
1612  return 0;
1613  }
1614 }
1615 
1616 LIB_EXPORT void jack_transport_start(jack_client_t* ext_client)
1617 {
1618  JackGlobals::CheckContext("jack_transport_start");
1619 
1620  JackClient* client = (JackClient*)ext_client;
1621  if (client == NULL) {
1622  jack_error("jack_transport_start called with a NULL client");
1623  } else {
1624  client->TransportStart();
1625  }
1626 }
1627 
1628 LIB_EXPORT void jack_transport_stop(jack_client_t* ext_client)
1629 {
1630  JackGlobals::CheckContext("jack_transport_stop");
1631 
1632  JackClient* client = (JackClient*)ext_client;
1633  if (client == NULL) {
1634  jack_error("jack_transport_stop called with a NULL client");
1635  } else {
1636  client->TransportStop();
1637  }
1638 }
1639 
1640 // deprecated
1641 LIB_EXPORT void jack_get_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)
1642 {
1643  JackGlobals::CheckContext("jack_get_transport_info");
1644 
1645  jack_error("jack_get_transport_info: deprecated");
1646  if (tinfo)
1647  memset(tinfo, 0, sizeof(jack_transport_info_t));
1648 }
1649 
1650 LIB_EXPORT void jack_set_transport_info(jack_client_t* ext_client, jack_transport_info_t* tinfo)
1651 {
1652  JackGlobals::CheckContext("jack_set_transport_info");
1653 
1654  jack_error("jack_set_transport_info: deprecated");
1655  if (tinfo)
1656  memset(tinfo, 0, sizeof(jack_transport_info_t));
1657 }
1658 
1659 // statistics.h
1660 LIB_EXPORT float jack_get_max_delayed_usecs(jack_client_t* ext_client)
1661 {
1662  JackGlobals::CheckContext("jack_get_max_delayed_usecs");
1663 
1664  JackClient* client = (JackClient*)ext_client;
1665  if (client == NULL) {
1666  jack_error("jack_get_max_delayed_usecs called with a NULL client");
1667  return 0.f;
1668  } else {
1669  JackEngineControl* control = GetEngineControl();
1670  return (control ? control->fMaxDelayedUsecs : 0.f);
1671  }
1672  }
1673 
1674 LIB_EXPORT float jack_get_xrun_delayed_usecs(jack_client_t* ext_client)
1675 {
1676  JackGlobals::CheckContext("jack_get_xrun_delayed_usecs");
1677 
1678  JackClient* client = (JackClient*)ext_client;
1679  if (client == NULL) {
1680  jack_error("jack_get_xrun_delayed_usecs called with a NULL client");
1681  return 0.f;
1682  } else {
1683  JackEngineControl* control = GetEngineControl();
1684  return (control ? control->fXrunDelayedUsecs : 0.f);
1685  }
1686 }
1687 
1688 LIB_EXPORT void jack_reset_max_delayed_usecs(jack_client_t* ext_client)
1689 {
1690  JackGlobals::CheckContext("jack_reset_max_delayed_usecs");
1691 
1692  JackClient* client = (JackClient*)ext_client;
1693  if (client == NULL) {
1694  jack_error("jack_reset_max_delayed_usecs called with a NULL client");
1695  } else {
1696  JackEngineControl* control = GetEngineControl();
1697  control->ResetXRun();
1698  }
1699 }
1700 
1701 // thread.h
1702 LIB_EXPORT int jack_client_real_time_priority(jack_client_t* ext_client)
1703 {
1704  JackGlobals::CheckContext("jack_client_real_time_priority");
1705 
1706  JackClient* client = (JackClient*)ext_client;
1707  if (client == NULL) {
1708  jack_error("jack_client_real_time_priority called with a NULL client");
1709  return -1;
1710  } else {
1711  JackEngineControl* control = GetEngineControl();
1712  return (control->fRealTime) ? control->fClientPriority : -1;
1713  }
1714 }
1715 
1716 LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t* ext_client)
1717 {
1718  JackGlobals::CheckContext("jack_client_max_real_time_priority");
1719 
1720  JackClient* client = (JackClient*)ext_client;
1721  if (client == NULL) {
1722  jack_error("jack_client_max_real_time_priority called with a NULL client");
1723  return -1;
1724  } else {
1725  JackEngineControl* control = GetEngineControl();
1726  return (control->fRealTime) ? control->fMaxClientPriority : -1;
1727  }
1728 }
1729 
1730 LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority)
1731 {
1732  JackEngineControl* control = GetEngineControl();
1733  return (control
1734  ? JackThread::AcquireRealTimeImp(thread, priority, control->fPeriod, control->fComputation, control->fConstraint)
1735  : -1);
1736 }
1737 
1738 LIB_EXPORT int jack_client_create_thread(jack_client_t* client,
1739  jack_native_thread_t *thread,
1740  int priority,
1741  int realtime, /* boolean */
1742  thread_routine routine,
1743  void *arg)
1744 {
1745  JackGlobals::CheckContext("jack_client_create_thread");
1746 
1747  JackEngineControl* control = GetEngineControl();
1748  int res = JackThread::StartImp(thread, priority, realtime, routine, arg);
1749  return (res == 0)
1750  ? ((realtime ? JackThread::AcquireRealTimeImp(*thread, priority, control->fPeriod, control->fComputation, control->fConstraint) : res))
1751  : res;
1752 }
1753 
1754 LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread)
1755 {
1756  return JackThread::DropRealTimeImp(thread);
1757 }
1758 
1759 LIB_EXPORT int jack_client_stop_thread(jack_client_t* client, jack_native_thread_t thread)
1760 {
1761  JackGlobals::CheckContext("jack_client_stop_thread");
1762  return JackThread::StopImp(thread);
1763 }
1764 
1765 LIB_EXPORT int jack_client_kill_thread(jack_client_t* client, jack_native_thread_t thread)
1766 {
1767  JackGlobals::CheckContext("jack_client_kill_thread");
1768  return JackThread::KillImp(thread);
1769 }
1770 
1771 #ifndef WIN32
1772 LIB_EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc)
1773 {
1774  if (jtc == NULL) {
1775  JackGlobals::fJackThreadCreator = pthread_create;
1776  } else {
1777  JackGlobals::fJackThreadCreator = jtc;
1778  }
1779 }
1780 #endif
1781 
1782 // intclient.h
1783 LIB_EXPORT int jack_internal_client_new (const char* client_name,
1784  const char* load_name,
1785  const char* load_init)
1786 {
1787  JackGlobals::CheckContext("jack_internal_client_new");
1788  jack_error("jack_internal_client_new: deprecated");
1789  return -1;
1790 }
1791 
1792 LIB_EXPORT void jack_internal_client_close (const char* client_name)
1793 {
1794  JackGlobals::CheckContext("jack_internal_client_close");
1795  jack_error("jack_internal_client_close: deprecated");
1796 }
1797 
1798 LIB_EXPORT char* jack_get_internal_client_name(jack_client_t* ext_client, jack_intclient_t intclient)
1799 {
1800  JackGlobals::CheckContext("jack_get_internal_client_name");
1801 
1802  JackClient* client = (JackClient*)ext_client;
1803  if (client == NULL) {
1804  jack_error("jack_get_internal_client_name called with a NULL client");
1805  return NULL;
1806  } else if (intclient >= CLIENT_NUM) {
1807  jack_error("jack_get_internal_client_name: incorrect client");
1808  return NULL;
1809  } else {
1810  return client->GetInternalClientName(intclient);
1811  }
1812 }
1813 
1814 LIB_EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t* ext_client, const char* client_name, jack_status_t* status)
1815 {
1816  JackGlobals::CheckContext("jack_internal_client_handle");
1817 
1818  JackClient* client = (JackClient*)ext_client;
1819  if (client == NULL) {
1820  jack_error("jack_internal_client_handle called with a NULL client");
1821  return 0;
1822  } else {
1823  jack_status_t my_status;
1824  if (status == NULL) /* no status from caller? */
1825  status = &my_status; /* use local status word */
1826  *status = (jack_status_t)0;
1827  return client->InternalClientHandle(client_name, status);
1828  }
1829 }
1830 
1831 static 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)
1832 {
1833  JackGlobals::CheckContext("jack_internal_client_load_aux");
1834 
1835  JackClient* client = (JackClient*)ext_client;
1836  if (client == NULL) {
1837  jack_error("jack_internal_client_load called with a NULL client");
1838  return 0;
1839  } else {
1840  jack_varargs_t va;
1841  jack_status_t my_status;
1842 
1843  if (status == NULL) /* no status from caller? */
1844  status = &my_status; /* use local status word */
1845  *status = (jack_status_t)0;
1846 
1847  /* validate parameters */
1848  if ((options & ~JackLoadOptions)) {
1849  int my_status1 = *status | (JackFailure | JackInvalidOption);
1850  *status = (jack_status_t)my_status1;
1851  return 0;
1852  }
1853 
1854  /* parse variable arguments */
1855  jack_varargs_parse(options, ap, &va);
1856  return client->InternalClientLoad(client_name, options, status, &va);
1857  }
1858 }
1859 
1860 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, ...)
1861 {
1862  JackGlobals::CheckContext("jack_internal_client_load");
1863 
1864  va_list ap;
1865  va_start(ap, status);
1866  jack_intclient_t res = jack_internal_client_load_aux(client, client_name, options, status, ap);
1867  va_end(ap);
1868  return res;
1869 }
1870 
1871 LIB_EXPORT jack_status_t jack_internal_client_unload(jack_client_t* ext_client, jack_intclient_t intclient)
1872 {
1873  JackGlobals::CheckContext("jack_internal_client_load");
1874 
1875  JackClient* client = (JackClient*)ext_client;
1876  if (client == NULL) {
1877  jack_error("jack_internal_client_unload called with a NULL client");
1878  return (jack_status_t)(JackNoSuchClient | JackFailure);
1879  } else if (intclient >= CLIENT_NUM) {
1880  jack_error("jack_internal_client_unload: incorrect client");
1881  return (jack_status_t)(JackNoSuchClient | JackFailure);
1882  } else {
1883  jack_status_t my_status;
1884  client->InternalClientUnload(intclient, &my_status);
1885  return my_status;
1886  }
1887 }
1888 
1889 LIB_EXPORT void jack_get_version(int *major_ptr,
1890  int *minor_ptr,
1891  int *micro_ptr,
1892  int *proto_ptr)
1893 {
1894  JackGlobals::CheckContext("jack_get_version");
1895 
1896  // FIXME: We need these coming from build system
1897  *major_ptr = 0;
1898  *minor_ptr = 0;
1899  *micro_ptr = 0;
1900  *proto_ptr = 0;
1901 }
1902 
1903 LIB_EXPORT const char* jack_get_version_string()
1904 {
1905  JackGlobals::CheckContext("jack_get_version_string");
1906  return VERSION;
1907 }
1908 
1909 LIB_EXPORT void jack_free(void* ptr)
1910 {
1911  JackGlobals::CheckContext("jack_free");
1912 
1913  if (ptr) {
1914  free(ptr);
1915  }
1916 }
1917 
1918 // session.h
1919 LIB_EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg)
1920 {
1921  JackGlobals::CheckContext("jack_set_session_callback");
1922 
1923  JackClient* client = (JackClient*)ext_client;
1924  jack_log("jack_set_session_callback ext_client %x client %x ", ext_client, client);
1925  if (client == NULL) {
1926  jack_error("jack_set_session_callback called with a NULL client");
1927  return -1;
1928  } else {
1929  return client->SetSessionCallback(session_callback, arg);
1930  }
1931 }
1932 
1933 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)
1934 {
1935  JackGlobals::CheckContext("jack_session_notify");
1936 
1937  JackClient* client = (JackClient*)ext_client;
1938  jack_log("jack_session_notify ext_client %x client %x ", ext_client, client);
1939  if (client == NULL) {
1940  jack_error("jack_session_notify called with a NULL client");
1941  return NULL;
1942  } else {
1943  return client->SessionNotify(target, ev_type, path);
1944  }
1945 }
1946 
1947 LIB_EXPORT int jack_session_reply(jack_client_t* ext_client, jack_session_event_t *event)
1948 {
1949  JackGlobals::CheckContext("jack_session_reply");
1950 
1951  JackClient* client = (JackClient*)ext_client;
1952  jack_log("jack_session_reply ext_client %x client %x ", ext_client, client);
1953  if (client == NULL) {
1954  jack_error("jack_session_reply called with a NULL client");
1955  return -1;
1956  } else {
1957  return client->SessionReply(event);
1958  }
1959 }
1960 
1961 LIB_EXPORT void jack_session_event_free(jack_session_event_t* ev)
1962 {
1963  JackGlobals::CheckContext("jack_session_event_free");
1964 
1965  if (ev) {
1966  if (ev->session_dir)
1967  free((void *)ev->session_dir);
1968  if (ev->client_uuid)
1969  free((void *)ev->client_uuid);
1970  if (ev->command_line)
1971  free(ev->command_line);
1972  free(ev);
1973  }
1974 }
1975 
1976 LIB_EXPORT char *jack_client_get_uuid(jack_client_t* ext_client)
1977 {
1978  JackGlobals::CheckContext("jack_client_get_uuid");
1979 
1980  JackClient* client = (JackClient*)ext_client;
1981  if (client == NULL) {
1982  jack_error("jack_client_get_uuid called with a NULL client");
1983  return NULL;
1984  } else {
1985  char retval[JACK_UUID_STRING_SIZE];
1986  jack_uuid_unparse(client->GetClientControl()->fSessionID, retval);
1987  return strdup(retval);
1988  }
1989 }
1990 
1991 LIB_EXPORT char* jack_get_uuid_for_client_name(jack_client_t* ext_client, const char* client_name)
1992 {
1993  JackGlobals::CheckContext("jack_get_uuid_for_client_name");
1994 
1995  JackClient* client = (JackClient*)ext_client;
1996  jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);
1997  if (client == NULL) {
1998  jack_error("jack_get_uuid_for_client_name called with a NULL client");
1999  return NULL;
2000  } else {
2001  return client->GetUUIDForClientName(client_name);
2002  }
2003 }
2004 
2005 LIB_EXPORT char* jack_get_client_name_by_uuid(jack_client_t* ext_client, const char* client_uuid)
2006 {
2007  JackGlobals::CheckContext("jack_get_client_name_by_uuid");
2008 
2009  JackClient* client = (JackClient*)ext_client;
2010  jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);
2011  if (client == NULL) {
2012  jack_error("jack_get_client_name_by_uuid called with a NULL client");
2013  return NULL;
2014  } else {
2015  return client->GetClientNameByUUID(client_uuid);
2016  }
2017 }
2018 
2019 LIB_EXPORT int jack_reserve_client_name(jack_client_t* ext_client, const char* client_name, const char* uuid)
2020 {
2021  JackGlobals::CheckContext("jack_reserve_client_name");
2022 
2023  JackClient* client = (JackClient*)ext_client;
2024  jack_log("jack_reserve_client_name ext_client %x client %x ", ext_client, client);
2025  if (client == NULL) {
2026  jack_error("jack_reserve_client_name called with a NULL client");
2027  return -1;
2028  } else {
2029  return client->ReserveClientName(client_name, uuid);
2030  }
2031 }
2032 
2033 LIB_EXPORT void jack_session_commands_free(jack_session_command_t *cmds)
2034 {
2035  JackGlobals::CheckContext("jack_session_commands_free");
2036 
2037 
2038  if (!cmds) {
2039  return;
2040  }
2041 
2042  int i = 0;
2043  while (1) {
2044  if (cmds[i].client_name) {
2045  free ((char *)cmds[i].client_name);
2046  }
2047  if (cmds[i].command) {
2048  free ((char *)cmds[i].command);
2049  }
2050  if (cmds[i].uuid) {
2051  free ((char *)cmds[i].uuid);
2052  } else {
2053  break;
2054  }
2055 
2056  i += 1;
2057  }
2058 
2059  free(cmds);
2060 }
2061 
2062 LIB_EXPORT int jack_client_has_session_callback(jack_client_t* ext_client, const char* client_name)
2063 {
2064  JackGlobals::CheckContext("jack_client_has_session_callback");
2065 
2066  JackClient* client = (JackClient*)ext_client;
2067  jack_log("jack_client_has_session_callback ext_client %x client %x ", ext_client, client);
2068  if (client == NULL) {
2069  jack_error("jack_client_has_session_callback called with a NULL client");
2070  return -1;
2071  } else {
2072  return client->ClientHasSessionCallback(client_name);
2073  }
2074 }
2075 
2076 LIB_EXPORT jack_uuid_t jack_client_uuid_generate()
2077 {
2078  static uint32_t uuid_cnt = 0;
2079  jack_uuid_t uuid = 0x2; /* JackUUIDClient */;
2080  uuid = (uuid << 32) | ++uuid_cnt;
2081  return uuid;
2082 }
2083 
2084 LIB_EXPORT jack_uuid_t jack_port_uuid_generate(uint32_t port_id)
2085 {
2086  jack_uuid_t uuid = 0x1; /* JackUUIDPort */
2087  uuid = (uuid << 32) | (port_id + 1);
2088  return uuid;
2089 }
2090 
2091 LIB_EXPORT uint32_t jack_uuid_to_index(jack_uuid_t u)
2092 {
2093  return (u & 0xffff) - 1;
2094 }
2095 
2096 LIB_EXPORT int jack_uuid_compare(jack_uuid_t a, jack_uuid_t b)
2097 {
2098  if (a == b) {
2099  return 0;
2100  }
2101 
2102  if (a < b) {
2103  return -1;
2104  }
2105 
2106  return 1;
2107 }
2108 
2109 LIB_EXPORT void jack_uuid_copy(jack_uuid_t* dst, jack_uuid_t src)
2110 {
2111  *dst = src;
2112 }
2113 
2114 LIB_EXPORT void jack_uuid_clear(jack_uuid_t* u)
2115 {
2116  *u = JACK_UUID_EMPTY_INITIALIZER;
2117 }
2118 
2119 LIB_EXPORT int jack_uuid_parse(const char* b, jack_uuid_t* u)
2120 {
2121  if (sscanf (b, "%" PRIu64, u) == 1) {
2122 
2123  if (*u < (0x1LL << 32)) {
2124  /* has not type bits set - not legal */
2125  return -1;
2126  }
2127 
2128  return 0;
2129  }
2130 
2131  return -1;
2132 }
2133 
2134 LIB_EXPORT void jack_uuid_unparse(jack_uuid_t u, char b[JACK_UUID_STRING_SIZE])
2135 {
2136  snprintf (b, JACK_UUID_STRING_SIZE, "%" PRIu64, u);
2137 }
2138 
2139 LIB_EXPORT int jack_uuid_empty(jack_uuid_t u)
2140 {
2141  return u == JACK_UUID_EMPTY_INITIALIZER;
2142 }
_jack_position
Definition: types.h:554
jack_port_get_total_latency
LIB_EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t *, jack_port_t *port)
Definition: JackAPI.cpp:1177
jack_set_client_registration_callback
LIB_EXPORT int jack_set_client_registration_callback(jack_client_t *, JackClientRegistrationCallback registration_callback, void *arg)
Definition: JackAPI.cpp:954
jack_port_request_monitor
LIB_EXPORT int jack_port_request_monitor(jack_port_t *port, int onoff)
Definition: JackAPI.cpp:717
jack_set_freewheel_callback
LIB_EXPORT int jack_set_freewheel_callback(jack_client_t *client, JackFreewheelCallback freewheel_callback, void *arg)
Definition: JackAPI.cpp:887
Jack::JackAtomicState::ReadCurrentState
T * ReadCurrentState()
Returns the current state : only valid in the RT reader thread.
Definition: JackAtomicState.h:144
jack_set_graph_order_callback
LIB_EXPORT int jack_set_graph_order_callback(jack_client_t *, JackGraphOrderCallback graph_callback, void *)
Definition: JackAPI.cpp:1006
jack_set_buffer_size
LIB_EXPORT int jack_set_buffer_size(jack_client_t *client, jack_nframes_t nframes)
Definition: JackAPI.cpp:913
Jack::JackTimer
A structure used for time management.
Definition: JackFrameTimer.h:36
jack_port_unregister
LIB_EXPORT int jack_port_unregister(jack_client_t *, jack_port_t *)
Definition: JackAPI.cpp:1102
jack_info_callback
SERVER_EXPORT void(* jack_info_callback)(const char *desc)
Definition: JackError.cpp:137
jack_port_tie
LIB_EXPORT int jack_port_tie(jack_port_t *src, jack_port_t *dst)
Definition: JackAPI.cpp:492
jack_set_thread_init_callback
LIB_EXPORT int jack_set_thread_init_callback(jack_client_t *client, JackThreadInitCallback thread_init_callback, void *arg)
Definition: JackAPI.cpp:1046
jack_set_session_callback
LIB_EXPORT int jack_set_session_callback(jack_client_t *ext_client, JackSessionCallback session_callback, void *arg)
Definition: JackAPI.cpp:1919
_jack_session_event::client_uuid
const char * client_uuid
Definition: JackSession.h:48
jack_port_type_id
LIB_EXPORT jack_port_type_id_t jack_port_type_id(const jack_port_t *port)
Definition: JackAPI.cpp:436
jack_port_by_id
LIB_EXPORT jack_port_t * jack_port_by_id(jack_client_t *client, jack_port_id_t port_id)
Definition: JackAPI.cpp:1319
jack_port_set_latency
LIB_EXPORT void jack_port_set_latency(jack_port_t *, jack_nframes_t)
Definition: JackAPI.cpp:548
jack_port_set_alias
LIB_EXPORT int jack_port_set_alias(jack_port_t *port, const char *alias)
Definition: JackAPI.cpp:666
jack_varargs_t
Definition: varargs.h:34
jack_set_transport_info
LIB_EXPORT void jack_set_transport_info(jack_client_t *client, jack_transport_info_t *tinfo)
Definition: JackAPI.cpp:1650
jack_transport_info_t
Definition: types.h:711
jack_port_ensure_monitor
LIB_EXPORT int jack_port_ensure_monitor(jack_port_t *port, int onoff)
Definition: JackAPI.cpp:754
_jack_session_event
Definition: JackSession.h:45
jack_client_real_time_priority
LIB_EXPORT int jack_client_real_time_priority(jack_client_t *)
Definition: JackAPI.cpp:1702
jack_cycle_signal
LIB_EXPORT void jack_cycle_signal(jack_client_t *, int status)
Definition: JackAPI.cpp:862
jack_transport_query
LIB_EXPORT jack_transport_state_t jack_transport_query(const jack_client_t *client, jack_position_t *pos)
Definition: JackAPI.cpp:1576
jack_internal_client_close
LIB_EXPORT void jack_internal_client_close(const char *client_name)
Definition: JackAPI.cpp:1792
jack_cycle_wait
LIB_EXPORT jack_nframes_t jack_cycle_wait(jack_client_t *)
Definition: JackAPI.cpp:849
_jack_session_event::session_dir
const char * session_dir
Definition: JackSession.h:47
jack_port_name_size
LIB_EXPORT int jack_port_name_size(void)
Definition: JackAPI.cpp:1480
jack_set_process_callback
LIB_EXPORT int jack_set_process_callback(jack_client_t *client, JackProcessCallback process_callback, void *arg)
Definition: JackAPI.cpp:822
jack_recompute_total_latency
LIB_EXPORT int jack_recompute_total_latency(jack_client_t *, jack_port_t *port)
Definition: JackAPI.cpp:595
jack_activate
LIB_EXPORT int jack_activate(jack_client_t *client)
Definition: JackAPI.cpp:1060
jack_error_callback
SERVER_EXPORT void(* jack_error_callback)(const char *desc)
Definition: JackError.cpp:136
jack_client_stop_thread
LIB_EXPORT int jack_client_stop_thread(jack_client_t *client, jack_native_thread_t thread)
Definition: JackAPI.cpp:1759
jack_port_type
LIB_EXPORT const char * jack_port_type(const jack_port_t *port)
Definition: JackAPI.cpp:421
Jack::JackClient::Deactivate
virtual int Deactivate()
Need to stop thread after deactivating in the server.
Definition: JackClient.cpp:474
jack_set_info_function
void jack_set_info_function(void(*func)(const char *)) JACK_OPTIONAL_WEAK_EXPORT
jack_client_thread_id
LIB_EXPORT jack_native_thread_t jack_client_thread_id(jack_client_t *)
Definition: JackAPI.cpp:1449
jack_port_get_connections
LIB_EXPORT const char ** jack_port_get_connections(const jack_port_t *port)
Definition: JackAPI.cpp:1138
jack_error
SERVER_EXPORT void jack_error(const char *fmt,...)
Definition: JackError.cpp:92
jack_port_disconnect
LIB_EXPORT int jack_port_disconnect(jack_client_t *, jack_port_t *)
Definition: JackAPI.cpp:1236
jack_port_set_latency_range
LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
Definition: JackAPI.cpp:579
jack_get_client_name_by_uuid
LIB_EXPORT char * jack_get_client_name_by_uuid(jack_client_t *ext_client, const char *client_uuid)
Definition: JackAPI.cpp:2005
jack_client_get_uuid
LIB_EXPORT char * jack_client_get_uuid(jack_client_t *client)
Definition: JackAPI.cpp:1976
jack_connect
LIB_EXPORT int jack_connect(jack_client_t *, const char *source_port, const char *destination_port)
Definition: JackAPI.cpp:1204
jack_port_uuid
LIB_EXPORT jack_uuid_t jack_port_uuid(const jack_port_t *)
Definition: JackAPI.cpp:362
jack_disconnect
LIB_EXPORT int jack_disconnect(jack_client_t *, const char *source_port, const char *destination_port)
Definition: JackAPI.cpp:1220
jack_port_register
LIB_EXPORT jack_port_t * jack_port_register(jack_client_t *client, const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size)
Definition: JackAPI.cpp:1086
jack_release_timebase
LIB_EXPORT int jack_release_timebase(jack_client_t *client)
Definition: JackAPI.cpp:1510
jack_port_get_all_connections
LIB_EXPORT const char ** jack_port_get_all_connections(const jack_client_t *client, const jack_port_t *port)
Definition: JackAPI.cpp:1155
jack_acquire_real_time_scheduling
LIB_EXPORT int jack_acquire_real_time_scheduling(jack_native_thread_t thread, int priority)
Definition: JackAPI.cpp:1730
jack_port_type_size
LIB_EXPORT int jack_port_type_size(void)
Definition: JackAPI.cpp:1485
jack_on_shutdown
LIB_EXPORT void jack_on_shutdown(jack_client_t *client, JackShutdownCallback shutdown_callback, void *arg)
Definition: JackAPI.cpp:798
jack_set_port_connect_callback
LIB_EXPORT int jack_set_port_connect_callback(jack_client_t *, JackPortConnectCallback connect_callback, void *arg)
Definition: JackAPI.cpp:980
jack_client_open
LIB_EXPORT jack_client_t * jack_client_open(const char *client_name, jack_options_t options, jack_status_t *status,...)
Definition: JackLibAPI.cpp:177
jack_frame_time
LIB_EXPORT jack_nframes_t jack_frame_time(const jack_client_t *)
Definition: JackAPI.cpp:1402
jack_get_client_name
LIB_EXPORT char * jack_get_client_name(jack_client_t *client)
Definition: JackAPI.cpp:1462
jack_last_frame_time
LIB_EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t *client)
Definition: JackAPI.cpp:1409
jack_port_monitoring_input
LIB_EXPORT int jack_port_monitoring_input(jack_port_t *port)
Definition: JackAPI.cpp:769
jack_client_has_session_callback
LIB_EXPORT int jack_client_has_session_callback(jack_client_t *client, const char *client_name)
Definition: JackAPI.cpp:2062
_jack_latency_range
Definition: types.h:265
jack_set_error_function
void jack_set_error_function(void(*func)(const char *)) JACK_OPTIONAL_WEAK_EXPORT
Jack::JackGraphManager
Graph manager: contains the connection manager and the port array.
Definition: JackGraphManager.h:40
jack_transport_start
LIB_EXPORT void jack_transport_start(jack_client_t *client)
Definition: JackAPI.cpp:1616
jack_session_commands_free
LIB_EXPORT void jack_session_commands_free(jack_session_command_t *cmds)
Definition: JackAPI.cpp:2033
jack_set_port_rename_callback
LIB_EXPORT int jack_set_port_rename_callback(jack_client_t *, JackPortRenameCallback rename_callback, void *arg)
Definition: JackAPI.cpp:993
jack_set_xrun_callback
LIB_EXPORT int jack_set_xrun_callback(jack_client_t *, JackXRunCallback xrun_callback, void *arg)
Definition: JackAPI.cpp:1020
jack_set_sync_timeout
LIB_EXPORT int jack_set_sync_timeout(jack_client_t *client, jack_time_t timeout)
Definition: JackAPI.cpp:1536
jack_session_notify
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)
Definition: JackAPI.cpp:1933
Jack::JackClient::Activate
virtual int Activate()
We need to start thread before activating in the server, otherwise the FW driver connected to the cli...
Definition: JackClient.cpp:441
jack_reserve_client_name
LIB_EXPORT int jack_reserve_client_name(jack_client_t *ext_client, const char *name, const char *uuid)
Definition: JackAPI.cpp:2019
jack_get_buffer_size
LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t *)
Definition: JackAPI.cpp:1268
jack_port_get_latency
LIB_EXPORT jack_nframes_t jack_port_get_latency(jack_port_t *port)
Definition: JackAPI.cpp:532
jack_port_untie
LIB_EXPORT int jack_port_untie(jack_port_t *port)
Definition: JackAPI.cpp:517
jack_client_max_real_time_priority
LIB_EXPORT int jack_client_max_real_time_priority(jack_client_t *)
Definition: JackAPI.cpp:1716
jack_set_thread_creator
LIB_EXPORT void jack_set_thread_creator(jack_thread_creator_t jtc)
Definition: JackAPI.cpp:1772
jack_set_sample_rate_callback
LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t *client, JackSampleRateCallback srate_callback, void *arg)
Definition: JackAPI.cpp:941
jack_transport_locate
LIB_EXPORT int jack_transport_locate(jack_client_t *client, jack_nframes_t frame)
Definition: JackAPI.cpp:1562
jack_port_get_buffer
LIB_EXPORT void * jack_port_get_buffer(jack_port_t *, jack_nframes_t)
Definition: JackAPI.cpp:347
jack_frames_to_time
LIB_EXPORT jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames)
Definition: JackAPI.cpp:1362
jack_port_get_aliases
LIB_EXPORT int jack_port_get_aliases(const jack_port_t *port, char *const aliases[2])
Definition: JackAPI.cpp:702
jack_transport_stop
LIB_EXPORT void jack_transport_stop(jack_client_t *client)
Definition: JackAPI.cpp:1628
jack_frames_since_cycle_start
LIB_EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t *)
Definition: JackAPI.cpp:1341
jack_session_command_t
Definition: JackSession.h:59
jack_recompute_total_latencies
LIB_EXPORT int jack_recompute_total_latencies(jack_client_t *)
Definition: JackAPI.cpp:616
jack_port_connected_to
LIB_EXPORT int jack_port_connected_to(const jack_port_t *port, const char *port_name)
Definition: JackAPI.cpp:467
jack_port_is_mine
LIB_EXPORT int jack_port_is_mine(const jack_client_t *, const jack_port_t *port)
Definition: JackAPI.cpp:1120
jack_port_unset_alias
LIB_EXPORT int jack_port_unset_alias(jack_port_t *port, const char *alias)
Definition: JackAPI.cpp:684
jack_client_create_thread
LIB_EXPORT int jack_client_create_thread(jack_client_t *client, jack_native_thread_t *thread, int priority, int realtime, thread_routine routine, void *arg)
Definition: JackAPI.cpp:1738
jack_drop_real_time_scheduling
LIB_EXPORT int jack_drop_real_time_scheduling(jack_native_thread_t thread)
Definition: JackAPI.cpp:1754
jack_transport_reposition
LIB_EXPORT int jack_transport_reposition(jack_client_t *client, const jack_position_t *pos)
Definition: JackAPI.cpp:1602
jack_port_by_name
LIB_EXPORT jack_port_t * jack_port_by_name(jack_client_t *, const char *port_name)
Definition: JackAPI.cpp:1295
jack_get_time
LIB_EXPORT jack_time_t jack_get_time()
Definition: JackAPI.cpp:1355
jack_get_sample_rate
LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t *)
Definition: JackAPI.cpp:1254
jack_set_timebase_callback
LIB_EXPORT int jack_set_timebase_callback(jack_client_t *client, int conditional, JackTimebaseCallback timebase_callback, void *arg)
Definition: JackAPI.cpp:1549
jack_port_type_get_buffer_size
LIB_EXPORT size_t jack_port_type_get_buffer_size(jack_client_t *client, const char *port_type)
Definition: JackAPI.cpp:1490
jack_set_buffer_size_callback
LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t *client, JackBufferSizeCallback bufsize_callback, void *arg)
Definition: JackAPI.cpp:928
jack_port_set_name
LIB_EXPORT int jack_port_set_name(jack_port_t *port, const char *port_name)
Definition: JackAPI.cpp:629
jack_cpu_load
LIB_EXPORT float jack_cpu_load(jack_client_t *client)
Definition: JackAPI.cpp:1435
jack_set_sync_callback
LIB_EXPORT int jack_set_sync_callback(jack_client_t *client, JackSyncCallback sync_callback, void *arg)
Definition: JackAPI.cpp:1523
jack_port_connected
LIB_EXPORT int jack_port_connected(const jack_port_t *port)
Definition: JackAPI.cpp:451
jack_on_info_shutdown
LIB_EXPORT void jack_on_info_shutdown(jack_client_t *client, JackInfoShutdownCallback shutdown_callback, void *arg)
Definition: JackAPI.cpp:810
jack_port_request_monitor_by_name
LIB_EXPORT int jack_port_request_monitor_by_name(jack_client_t *client, const char *port_name, int onoff)
Definition: JackAPI.cpp:732
Jack::JackGraphManager::RequestMonitor
int RequestMonitor(jack_port_id_t port_index, bool onoff)
Definition: JackGraphManager.cpp:228
jack_internal_client_new
LIB_EXPORT int jack_internal_client_new(const char *client_name, const char *load_name, const char *load_init)
Definition: JackAPI.cpp:1783
jack_get_uuid_for_client_name
LIB_EXPORT char * jack_get_uuid_for_client_name(jack_client_t *ext_client, const char *client_name)
Definition: JackAPI.cpp:1991
jack_session_reply
LIB_EXPORT int jack_session_reply(jack_client_t *ext_client, jack_session_event_t *event)
Definition: JackAPI.cpp:1947
jack_engine_takeover_timebase
LIB_EXPORT int jack_engine_takeover_timebase(jack_client_t *)
Definition: JackAPI.cpp:1327
jack_get_cycle_times
LIB_EXPORT int jack_get_cycle_times(const jack_client_t *client, jack_nframes_t *current_frames, jack_time_t *current_usecs, jack_time_t *next_usecs, float *period_usecs)
Definition: JackAPI.cpp:1417
Jack::JackEngineControl
Engine control in shared memory.
Definition: JackEngineControl.h:49
jack_thread_wait
LIB_EXPORT jack_nframes_t jack_thread_wait(jack_client_t *client, int status)
Definition: JackAPI.cpp:835
jack_port_name
LIB_EXPORT const char * jack_port_name(const jack_port_t *port)
Definition: JackAPI.cpp:376
jack_client_name_size
LIB_EXPORT int jack_client_name_size(void)
Definition: JackAPI.cpp:1475
jack_time_to_frames
LIB_EXPORT jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t usecs)
Definition: JackAPI.cpp:1382
jack_get_ports
LIB_EXPORT const char ** jack_get_ports(jack_client_t *, const char *port_name_pattern, const char *type_name_pattern, unsigned long flags)
Definition: JackAPI.cpp:1282
jack_port_flags
LIB_EXPORT int jack_port_flags(const jack_port_t *port)
Definition: JackAPI.cpp:406
jack_set_port_registration_callback
LIB_EXPORT int jack_set_port_registration_callback(jack_client_t *, JackPortRegistrationCallback registration_callback, void *arg)
Definition: JackAPI.cpp:967
jack_deactivate
LIB_EXPORT int jack_deactivate(jack_client_t *client)
Definition: JackAPI.cpp:1073
jack_client_new
LIB_EXPORT jack_client_t * jack_client_new(const char *client_name)
Definition: JackAPI.cpp:323
jack_set_process_thread
LIB_EXPORT int jack_set_process_thread(jack_client_t *client, JackThreadCallback fun, void *arg)
Definition: JackAPI.cpp:874
jack_port_rename
LIB_EXPORT int jack_port_rename(jack_client_t *client, jack_port_t *port, const char *port_name)
Definition: JackAPI.cpp:645
jack_get_transport_info
LIB_EXPORT void jack_get_transport_info(jack_client_t *client, jack_transport_info_t *tinfo)
Definition: JackAPI.cpp:1641
jack_log
SERVER_EXPORT void jack_log(const char *fmt,...)
Definition: JackError.cpp:108
jack_get_current_transport_frame
LIB_EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t *client)
Definition: JackAPI.cpp:1589
JackSessionCallback
void(* JackSessionCallback)(jack_session_event_t *event, void *arg)
Definition: session.h:162
jack_port_get_latency_range
LIB_EXPORT void jack_port_get_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
Definition: JackAPI.cpp:563
_jack_session_event::command_line
char * command_line
Definition: JackSession.h:49
jack_port_short_name
LIB_EXPORT const char * jack_port_short_name(const jack_port_t *port)
Definition: JackAPI.cpp:391
Jack::JackPort::EnsureMonitor
int EnsureMonitor(bool onoff)
Definition: JackPort.cpp:176
Jack::JackClient
The base class for clients: share part of the implementation for JackInternalClient and JackLibClient...
Definition: JackClient.h:48
jack_client_kill_thread
LIB_EXPORT int jack_client_kill_thread(jack_client_t *client, jack_native_thread_t thread)
Definition: JackAPI.cpp:1765
jack_session_event_free
LIB_EXPORT void jack_session_event_free(jack_session_event_t *ev)
Definition: JackAPI.cpp:1961
jack_set_freewheel
LIB_EXPORT int jack_set_freewheel(jack_client_t *client, int onoff)
Definition: JackAPI.cpp:900
Generated by   doxygen 1.8.6