Jack2  1.9.10
Jackdmp.cpp
1 /*
2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2004-2013 Grame
4 
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 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 General Public License for more details.
14 
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 
19 */
20 
21 #include <iostream>
22 #include <assert.h>
23 #include <cassert>
24 #include <csignal>
25 #include <sys/types.h>
26 #include <getopt.h>
27 #include <cstring>
28 #include <cstdio>
29 #include <list>
30 
31 #include "types.h"
32 #include "jack.h"
33 #include "control.h"
34 #include "JackConstants.h"
35 #include "JackPlatformPlug.h"
36 #ifdef __ANDROID__
37 #include "JackControlAPIAndroid.h"
38 #endif
39 
40 #if defined(JACK_DBUS) && defined(__linux__)
41 #include <dbus/dbus.h>
42 #include "audio_reserve.h"
43 #endif
44 
45 /*
46 This is a simple port of the old jackdmp.cpp file to use the new jack2 control API. Available options for the server
47 are "hard-coded" in the source. A much better approach would be to use the control API to:
48 - dynamically retrieve available server parameters and then prepare to parse them
49 - get available drivers and their possible parameters, then prepare to parse them.
50 */
51 
52 #ifdef __APPLE__
53 #include <CoreFoundation/CFNotificationCenter.h>
54 #include <CoreFoundation/CoreFoundation.h>
55 
56 static void notify_server_start(const char* server_name)
57 {
58  // Send notification to be used in the JackRouter plugin
59  CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
60  CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
61  CFSTR("com.grame.jackserver.start"),
62  ref,
63  NULL,
64  kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
65  CFRelease(ref);
66 }
67 
68 static void notify_server_stop(const char* server_name)
69 {
70  // Send notification to be used in the JackRouter plugin
71  CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
72  CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
73  CFSTR("com.grame.jackserver.stop"),
74  ref1,
75  NULL,
76  kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
77  CFRelease(ref1);
78 }
79 
80 #else
81 
82 static void notify_server_start(const char* server_name)
83 {}
84 static void notify_server_stop(const char* server_name)
85 {}
86 
87 #endif
88 
89 static void copyright(FILE* file)
90 {
91  fprintf(file, "jackdmp " VERSION "\n"
92  "Copyright 2001-2005 Paul Davis and others.\n"
93  "Copyright 2004-2014 Grame.\n"
94  "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
95  "This is free software, and you are welcome to redistribute it\n"
96  "under certain conditions; see the file COPYING for details\n");
97 }
98 
99 static jackctl_driver_t * jackctl_server_get_driver(jackctl_server_t *server, const char *driver_name)
100 {
101  const JSList * node_ptr = jackctl_server_get_drivers_list(server);
102 
103  while (node_ptr) {
104  if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0) {
105  return (jackctl_driver_t *)node_ptr->data;
106  }
107  node_ptr = jack_slist_next(node_ptr);
108  }
109 
110  return NULL;
111 }
112 
113 static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
114 {
115  const JSList * node_ptr = jackctl_server_get_internals_list(server);
116 
117  while (node_ptr) {
118  if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
119  return (jackctl_internal_t *)node_ptr->data;
120  }
121  node_ptr = jack_slist_next(node_ptr);
122  }
123 
124  return NULL;
125 }
126 
127 static jackctl_parameter_t * jackctl_get_parameter(const JSList * parameters_list, const char * parameter_name)
128 {
129  while (parameters_list) {
130  if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0) {
131  return (jackctl_parameter_t *)parameters_list->data;
132  }
133  parameters_list = jack_slist_next(parameters_list);
134  }
135 
136  return NULL;
137 }
138 
139 #ifdef __ANDROID__
140 static void jackctl_server_switch_master_dummy(jackctl_server_t * server_ctl, char * master_driver_name)
141 {
142  static bool is_dummy_driver = false;
143  if(!strcmp(master_driver_name, "dummy")) {
144  return;
145  }
146  jackctl_driver_t * driver_ctr;
147  if(is_dummy_driver) {
148  is_dummy_driver = false;
149  driver_ctr = jackctl_server_get_driver(server_ctl, master_driver_name);
150  } else {
151  is_dummy_driver = true;
152  driver_ctr = jackctl_server_get_driver(server_ctl, "dummy");
153  }
154  jackctl_server_switch_master(server_ctl, driver_ctr);
155 }
156 #endif
157 
158 static void print_server_drivers(jackctl_server_t *server, FILE* file)
159 {
160  const JSList * node_ptr = jackctl_server_get_drivers_list(server);
161 
162  fprintf(file, "Available backends:\n");
163 
164  while (node_ptr) {
165  jackctl_driver_t* driver = (jackctl_driver_t *)node_ptr->data;
166  fprintf(file, " %s (%s)\n", jackctl_driver_get_name(driver), (jackctl_driver_get_type(driver) == JackMaster) ? "master" : "slave");
167  node_ptr = jack_slist_next(node_ptr);
168  }
169  fprintf(file, "\n");
170 }
171 
172 static void print_server_internals(jackctl_server_t *server, FILE* file)
173 {
174  const JSList * node_ptr = jackctl_server_get_internals_list(server);
175 
176  fprintf(file, "Available internals:\n");
177 
178  while (node_ptr) {
179  jackctl_internal_t* internal = (jackctl_internal_t *)node_ptr->data;
180  fprintf(file, " %s\n", jackctl_internal_get_name(internal));
181  node_ptr = jack_slist_next(node_ptr);
182  }
183  fprintf(file, "\n");
184 }
185 
186 static void usage(FILE* file, jackctl_server_t *server, bool full = true)
187 {
188  jackctl_parameter_t * param;
189  const JSList * server_parameters;
190  uint32_t i;
191  union jackctl_parameter_value value;
192 
193  fprintf(file, "\n"
194  "Usage: jackdmp [ --no-realtime OR -r ]\n"
195  " [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
196  " (the two previous arguments are mutually exclusive. The default is --realtime)\n"
197  " [ --name OR -n server-name ]\n"
198  " [ --timeout OR -t client-timeout-in-msecs ]\n"
199  " [ --loopback OR -L loopback-port-number ]\n"
200  " [ --port-max OR -p maximum-number-of-ports]\n"
201  " [ --slave-backend OR -X slave-backend-name ]\n"
202  " [ --internal-client OR -I internal-client-name ]\n"
203  " [ --verbose OR -v ]\n"
204 #ifdef __linux__
205  " [ --clocksource OR -c [ h(pet) | s(ystem) ]\n"
206 #endif
207  " [ --autoconnect OR -a <modechar>]\n");
208 
209  server_parameters = jackctl_server_get_parameters(server);
210  param = jackctl_get_parameter(server_parameters, "self-connect-mode");
211  fprintf(file,
212  " where <modechar> is one of:\n");
213  for (i = 0; i < jackctl_parameter_get_enum_constraints_count(param); i++)
214  {
216  fprintf(file, " '%c' - %s", value.c, jackctl_parameter_get_enum_constraint_description(param, i));
217  if (value.c == JACK_DEFAULT_SELF_CONNECT_MODE)
218  {
219  fprintf(file, " (default)");
220  }
221  fprintf(file, "\n");
222  }
223 
224  fprintf(file,
225  " [ --replace-registry ]\n"
226  " [ --silent OR -s ]\n"
227  " [ --sync OR -S ]\n"
228  " [ --temporary OR -T ]\n"
229  " [ --version OR -V ]\n"
230  " -d master-backend-name [ ... master-backend args ... ]\n"
231  " jackdmp -d master-backend-name --help\n"
232  " to display options for each master backend\n\n");
233 
234  if (full) {
235  print_server_drivers(server, file);
236  print_server_internals(server, file);
237  }
238 }
239 
240 // Prototype to be found in libjackserver
241 extern "C" void silent_jack_error_callback(const char *desc);
242 
243 int main(int argc, char** argv)
244 {
245  jackctl_server_t * server_ctl;
246  const JSList * server_parameters;
247  const char* server_name = JACK_DEFAULT_SERVER_NAME;
248  jackctl_driver_t * master_driver_ctl;
249  jackctl_driver_t * loopback_driver_ctl = NULL;
250  int replace_registry = 0;
251  const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
252  "a:"
253 #ifdef __linux__
254  "c:"
255 #endif
256  ;
257 
258  struct option long_options[] = {
259 #ifdef __linux__
260  { "clock-source", 1, 0, 'c' },
261 #endif
262  { "loopback-driver", 1, 0, 'L' },
263  { "audio-driver", 1, 0, 'd' },
264  { "midi-driver", 1, 0, 'X' },
265  { "internal-client", 1, 0, 'I' },
266  { "verbose", 0, 0, 'v' },
267  { "help", 0, 0, 'h' },
268  { "port-max", 1, 0, 'p' },
269  { "no-mlock", 0, 0, 'm' },
270  { "name", 1, 0, 'n' },
271  { "unlock", 0, 0, 'u' },
272  { "realtime", 0, 0, 'R' },
273  { "no-realtime", 0, 0, 'r' },
274  { "replace-registry", 0, &replace_registry, 0 },
275  { "loopback", 0, 0, 'L' },
276  { "realtime-priority", 1, 0, 'P' },
277  { "timeout", 1, 0, 't' },
278  { "temporary", 0, 0, 'T' },
279  { "version", 0, 0, 'V' },
280  { "silent", 0, 0, 's' },
281  { "sync", 0, 0, 'S' },
282  { "autoconnect", 1, 0, 'a' },
283  { 0, 0, 0, 0 }
284  };
285 
286  int i,opt = 0;
287  int option_index = 0;
288  char* master_driver_name = NULL;
289  char** master_driver_args = NULL;
290  int master_driver_nargs = 1;
291  int loopback = 0;
292  bool show_version = false;
293  jackctl_sigmask_t * sigmask;
294  jackctl_parameter_t* param;
295  union jackctl_parameter_value value;
296 
297  std::list<char*> internals_list;
298  std::list<char*> slaves_list;
299  std::list<char*>::iterator it;
300 
301  // Assume that we fail.
302  int return_value = -1;
303  bool notify_sent = false;
304 
305  copyright(stdout);
306 #if defined(JACK_DBUS) && defined(__linux__)
307  server_ctl = jackctl_server_create(audio_acquire, audio_release);
308 #else
309  server_ctl = jackctl_server_create(NULL, NULL);
310 #endif
311  if (server_ctl == NULL) {
312  fprintf(stderr, "Failed to create server object\n");
313  return -1;
314  }
315 
316  server_parameters = jackctl_server_get_parameters(server_ctl);
317 
318  opterr = 0;
319  while (!master_driver_name &&
320  (opt = getopt_long(argc, argv, options,
321  long_options, &option_index)) != EOF) {
322  switch (opt) {
323 
324  #ifdef __linux__
325  case 'c':
326  param = jackctl_get_parameter(server_parameters, "clock-source");
327  if (param != NULL) {
328  if (tolower (optarg[0]) == 'h') {
329  value.ui = JACK_TIMER_HPET;
330  jackctl_parameter_set_value(param, &value);
331  } else if (tolower (optarg[0]) == 'c') {
332  /* For backwards compatibility with scripts, allow
333  * the user to request the cycle clock on the
334  * command line, but use the system clock instead
335  */
336  value.ui = JACK_TIMER_SYSTEM_CLOCK;
337  jackctl_parameter_set_value(param, &value);
338  } else if (tolower (optarg[0]) == 's') {
339  value.ui = JACK_TIMER_SYSTEM_CLOCK;
340  jackctl_parameter_set_value(param, &value);
341  } else {
342  usage(stdout, server_ctl);
343  goto destroy_server;
344  }
345  }
346  break;
347  #endif
348 
349  case 'a':
350  param = jackctl_get_parameter(server_parameters, "self-connect-mode");
351  if (param != NULL) {
352  bool value_valid = false;
353  for (uint32_t k=0; k<jackctl_parameter_get_enum_constraints_count( param ); k++ ) {
355  if( value.c == optarg[0] )
356  value_valid = true;
357  }
358 
359  if( value_valid ) {
360  value.c = optarg[0];
361  jackctl_parameter_set_value(param, &value);
362  } else {
363  usage(stdout, server_ctl);
364  goto destroy_server;
365  }
366  }
367  break;
368 
369  case 'd':
370  master_driver_name = optarg;
371  break;
372 
373  case 'L':
374  loopback = atoi(optarg);
375  break;
376 
377  case 'X':
378  slaves_list.push_back(optarg);
379  break;
380 
381  case 'I':
382  internals_list.push_back(optarg);
383  break;
384 
385  case 'p':
386  param = jackctl_get_parameter(server_parameters, "port-max");
387  if (param != NULL) {
388  value.ui = atoi(optarg);
389  jackctl_parameter_set_value(param, &value);
390  }
391  break;
392 
393  case 'm':
394  break;
395 
396  case 'u':
397  break;
398 
399  case 'v':
400  param = jackctl_get_parameter(server_parameters, "verbose");
401  if (param != NULL) {
402  value.b = true;
403  jackctl_parameter_set_value(param, &value);
404  }
405  break;
406 
407  case 's':
408  jack_set_error_function(silent_jack_error_callback);
409  break;
410 
411  case 'S':
412  param = jackctl_get_parameter(server_parameters, "sync");
413  if (param != NULL) {
414  value.b = true;
415  jackctl_parameter_set_value(param, &value);
416  }
417  break;
418 
419  case 'n':
420  server_name = optarg;
421  param = jackctl_get_parameter(server_parameters, "name");
422  if (param != NULL) {
423  strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
424  jackctl_parameter_set_value(param, &value);
425  }
426  break;
427 
428  case 'P':
429  param = jackctl_get_parameter(server_parameters, "realtime-priority");
430  if (param != NULL) {
431  value.i = atoi(optarg);
432  jackctl_parameter_set_value(param, &value);
433  }
434  break;
435 
436  case 'r':
437  param = jackctl_get_parameter(server_parameters, "realtime");
438  if (param != NULL) {
439  value.b = false;
440  jackctl_parameter_set_value(param, &value);
441  }
442  break;
443 
444  case 'R':
445  param = jackctl_get_parameter(server_parameters, "realtime");
446  if (param != NULL) {
447  value.b = true;
448  jackctl_parameter_set_value(param, &value);
449  }
450  break;
451 
452  case 'T':
453  param = jackctl_get_parameter(server_parameters, "temporary");
454  if (param != NULL) {
455  value.b = true;
456  jackctl_parameter_set_value(param, &value);
457  }
458  break;
459 
460  case 't':
461  param = jackctl_get_parameter(server_parameters, "client-timeout");
462  if (param != NULL) {
463  value.i = atoi(optarg);
464  jackctl_parameter_set_value(param, &value);
465  }
466  break;
467 
468  case 'V':
469  show_version = true;
470  break;
471 
472  default:
473  fprintf(stderr, "unknown option character %c\n", optopt);
474  /*fallthru*/
475 
476  case 'h':
477  usage(stdout, server_ctl);
478  goto destroy_server;
479  }
480  }
481 
482  // Long option with no letter so treated separately
483  param = jackctl_get_parameter(server_parameters, "replace-registry");
484  if (param != NULL) {
485  value.b = replace_registry;
486  jackctl_parameter_set_value(param, &value);
487  }
488 
489  if (show_version) {
490  printf( "jackdmp version " VERSION
491  " tmpdir " jack_server_dir
492  " protocol %d"
493  "\n", JACK_PROTOCOL_VERSION);
494  return -1;
495  }
496 
497  if (!master_driver_name) {
498  usage(stderr, server_ctl, false);
499  goto destroy_server;
500  }
501 
502  // Master driver
503  master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
504  if (master_driver_ctl == NULL) {
505  fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name);
506  goto destroy_server;
507  }
508 
509  if (jackctl_driver_get_type(master_driver_ctl) != JackMaster) {
510  fprintf(stderr, "Driver \"%s\" is not a master \n", master_driver_name);
511  goto destroy_server;
512  }
513 
514  if (optind < argc) {
515  master_driver_nargs = 1 + argc - optind;
516  } else {
517  master_driver_nargs = 1;
518  }
519 
520  if (master_driver_nargs == 0) {
521  fprintf(stderr, "No driver specified ... hmm. JACK won't do"
522  " anything when run like this.\n");
523  goto destroy_server;
524  }
525 
526  master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs);
527  master_driver_args[0] = master_driver_name;
528 
529  for (i = 1; i < master_driver_nargs; i++) {
530  master_driver_args[i] = argv[optind++];
531  }
532 
533  if (jackctl_driver_params_parse(master_driver_ctl, master_driver_nargs, master_driver_args)) {
534  goto destroy_server;
535  }
536 
537  // Setup signals
538  sigmask = jackctl_setup_signals(0);
539 
540  // Open server
541  if (! jackctl_server_open(server_ctl, master_driver_ctl)) {
542  fprintf(stderr, "Failed to open server\n");
543  goto destroy_server;
544  }
545 
546  // Slave drivers
547  for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
548  jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
549  if (slave_driver_ctl == NULL) {
550  fprintf(stderr, "Unknown driver \"%s\"\n", *it);
551  goto close_server;
552  }
553  if (jackctl_driver_get_type(slave_driver_ctl) != JackSlave) {
554  fprintf(stderr, "Driver \"%s\" is not a slave \n", *it);
555  goto close_server;
556  }
557  if (!jackctl_server_add_slave(server_ctl, slave_driver_ctl)) {
558  fprintf(stderr, "Driver \"%s\" cannot be loaded\n", *it);
559  goto close_server;
560  }
561  }
562 
563  // Loopback driver
564  if (loopback > 0) {
565  loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
566 
567  if (loopback_driver_ctl != NULL) {
568  const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
569  param = jackctl_get_parameter(loopback_parameters, "channels");
570  if (param != NULL) {
571  value.ui = loopback;
572  jackctl_parameter_set_value(param, &value);
573  }
574  if (!jackctl_server_add_slave(server_ctl, loopback_driver_ctl)) {
575  fprintf(stderr, "Driver \"loopback\" cannot be loaded\n");
576  goto close_server;
577  }
578  } else {
579  fprintf(stderr, "Driver \"loopback\" not found\n");
580  goto close_server;
581  }
582  }
583 
584  // Start the server
585  if (!jackctl_server_start(server_ctl)) {
586  fprintf(stderr, "Failed to start server\n");
587  goto close_server;
588  }
589 
590  // Internal clients
591  for (it = internals_list.begin(); it != internals_list.end(); it++) {
592  jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
593  if (internal_driver_ctl == NULL) {
594  fprintf(stderr, "Unknown internal \"%s\"\n", *it);
595  goto stop_server;
596  }
597  if (!jackctl_server_load_internal(server_ctl, internal_driver_ctl)) {
598  fprintf(stderr, "Internal client \"%s\" cannot be loaded\n", *it);
599  goto stop_server;
600  }
601  }
602 
603  notify_server_start(server_name);
604  notify_sent = true;
605  return_value = 0;
606 
607  // Waits for signal
608 #ifdef __ANDROID__
609  //reserve SIGUSR2 signal for switching master driver
610  while(1) {
611  int signal = jackctl_wait_signals_and_return(sigmask);
612  if (signal == SIGUSR2) {
613  jackctl_server_switch_master_dummy(server_ctl, master_driver_name);
614  } else {
615  break;
616  }
617  }
618 #else
619  jackctl_wait_signals(sigmask);
620 #endif
621 
622  stop_server:
623  if (!jackctl_server_stop(server_ctl)) {
624  fprintf(stderr, "Cannot stop server...\n");
625  }
626 
627  close_server:
628  if (loopback > 0 && loopback_driver_ctl) {
629  jackctl_server_remove_slave(server_ctl, loopback_driver_ctl);
630  }
631  // Slave drivers
632  for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
633  jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
634  if (slave_driver_ctl) {
635  jackctl_server_remove_slave(server_ctl, slave_driver_ctl);
636  }
637  }
638 
639  // Internal clients
640  for (it = internals_list.begin(); it != internals_list.end(); it++) {
641  jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
642  if (internal_driver_ctl) {
643  jackctl_server_unload_internal(server_ctl, internal_driver_ctl);
644  }
645  }
646  jackctl_server_close(server_ctl);
647 
648  destroy_server:
649  jackctl_server_destroy(server_ctl);
650  if (notify_sent) {
651  notify_server_stop(server_name);
652  }
653  return return_value;
654 }
SERVER_EXPORT int jackctl_driver_params_parse(jackctl_driver *driver_ptr, int argc, char *argv[])
SERVER_EXPORT jackctl_sigmask_t * jackctl_setup_signals(unsigned int flags)
SERVER_EXPORT bool jackctl_server_open(jackctl_server *server_ptr, jackctl_driver *driver_ptr)
SERVER_EXPORT jackctl_server_t * jackctl_server_create(bool(*on_device_acquire)(const char *device_name), void(*on_device_release)(const char *device_name))
SERVER_EXPORT bool jackctl_server_switch_master(jackctl_server *server_ptr, jackctl_driver *driver_ptr)
SERVER_EXPORT const char * jackctl_internal_get_name(jackctl_internal *internal_ptr)
master driver
Definition: control.h:52
int32_t i
member used for JackParamInt
void jack_set_error_function(void(*func)(const char *)) JACK_OPTIONAL_WEAK_EXPORT
Definition: getopt.h:84
SERVER_EXPORT const char * jackctl_parameter_get_name(jackctl_parameter *parameter_ptr)
SERVER_EXPORT bool jackctl_server_stop(jackctl_server *server_ptr)
Type for parameter value.
SERVER_EXPORT const JSList * jackctl_driver_get_parameters(jackctl_driver *driver_ptr)
SERVER_EXPORT bool jackctl_server_close(jackctl_server *server_ptr)
SERVER_EXPORT bool jackctl_server_remove_slave(jackctl_server *server_ptr, jackctl_driver *driver_ptr)
SERVER_EXPORT const char * jackctl_parameter_get_enum_constraint_description(jackctl_parameter *parameter_ptr, uint32_t index)
SERVER_EXPORT const JSList * jackctl_server_get_internals_list(jackctl_server *server_ptr)
slave driver
Definition: control.h:53
SERVER_EXPORT const JSList * jackctl_server_get_drivers_list(jackctl_server *server_ptr)
SERVER_EXPORT bool jackctl_server_start(jackctl_server *server_ptr)
SERVER_EXPORT uint32_t jackctl_parameter_get_enum_constraints_count(jackctl_parameter *parameter_ptr)
SERVER_EXPORT bool jackctl_parameter_set_value(jackctl_parameter *parameter_ptr, const union jackctl_parameter_value *value_ptr)
SERVER_EXPORT bool jackctl_server_add_slave(jackctl_server *server_ptr, jackctl_driver *driver_ptr)
#define JACK_PARAM_STRING_MAX
Max length of string parameter value, excluding terminating null char.
Definition: control.h:60
SERVER_EXPORT const char * jackctl_driver_get_name(jackctl_driver *driver_ptr)
SERVER_EXPORT union jackctl_parameter_value jackctl_parameter_get_enum_constraint_value(jackctl_parameter *parameter_ptr, uint32_t index)
JACK control API.
SERVER_EXPORT bool jackctl_server_unload_internal(jackctl_server *server_ptr, jackctl_internal *internal)
SERVER_EXPORT void jackctl_server_destroy(jackctl_server *server_ptr)
SERVER_EXPORT jackctl_driver_type_t jackctl_driver_get_type(jackctl_driver *driver_ptr)
SERVER_EXPORT const JSList * jackctl_server_get_parameters(jackctl_server *server_ptr)
SERVER_EXPORT void jackctl_wait_signals(jackctl_sigmask_t *sigmask)
SERVER_EXPORT bool jackctl_server_load_internal(jackctl_server *server_ptr, jackctl_internal *internal)