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