37 #include "driver_interface.h"
38 #include "JackError.h"
39 #include "JackServer.h"
41 #include "JackTools.h"
42 #include "JackControlAPI.h"
43 #include "JackLockedEngine.h"
44 #include "JackConstants.h"
45 #include "JackDriverLoader.h"
46 #include "JackServerGlobals.h"
53 {
' ',
"Don't restrict self connect requests" },
54 {
'E',
"Fail self connect requests to external ports only" },
55 {
'e',
"Ignore self connect requests to external ports only" },
56 {
'A',
"Fail all self connect requests" },
57 {
'a',
"Ignore all self connect requests" },
131 const char * short_description;
132 const char * long_description;
133 jackctl_param_type_t type;
145 const char * jack_get_self_connect_mode_description(
char mode)
149 for (descr_ptr = self_connect_mode_constraint_descr_array;
152 if (descr_ptr->value == mode)
return descr_ptr->short_desc;
159 jackctl_add_parameter(
160 JSList ** parameters_list_ptr_ptr,
162 const char * short_description,
163 const char * long_description,
164 jackctl_param_type_t type,
173 if (parameter_ptr == NULL)
175 jack_error(
"Cannot allocate memory for jackctl_parameter structure.");
179 parameter_ptr->name = name;
180 parameter_ptr->short_description = short_description;
181 parameter_ptr->long_description = long_description;
182 parameter_ptr->type = type;
183 parameter_ptr->is_set =
false;
185 if (value_ptr == NULL)
187 value_ptr = ¶meter_ptr->value;
190 if (default_value_ptr == NULL)
192 default_value_ptr = ¶meter_ptr->default_value;
195 parameter_ptr->value_ptr = value_ptr;
196 parameter_ptr->default_value_ptr = default_value_ptr;
198 *value_ptr = *default_value_ptr = value;
200 parameter_ptr->driver_ptr = NULL;
201 parameter_ptr->id = 0;
202 parameter_ptr->constraint_ptr = constraint_ptr;
204 *parameters_list_ptr_ptr = jack_slist_append(*parameters_list_ptr_ptr, parameter_ptr);
206 return parameter_ptr;
214 jackctl_free_driver_parameters(
219 while (driver_ptr->parameters)
221 next_node_ptr = driver_ptr->parameters->next;
222 free(driver_ptr->parameters->data);
223 free(driver_ptr->parameters);
224 driver_ptr->parameters = next_node_ptr;
230 jackctl_add_driver_parameters(
236 jackctl_param_type_t jackctl_type;
240 for (i = 0 ; i < driver_ptr->desc_ptr->
nparams ; i++)
242 descriptor_ptr = driver_ptr->desc_ptr->
params + i;
244 switch (descriptor_ptr->
type)
246 case JackDriverParamInt:
248 jackctl_value.i = descriptor_ptr->
value.i;
250 case JackDriverParamUInt:
252 jackctl_value.ui = descriptor_ptr->
value.ui;
254 case JackDriverParamChar:
256 jackctl_value.c = descriptor_ptr->
value.c;
258 case JackDriverParamString:
260 strcpy(jackctl_value.str, descriptor_ptr->
value.str);
262 case JackDriverParamBool:
264 jackctl_value.b = descriptor_ptr->
value.i;
267 jack_error(
"Unknown driver parameter type %i", (
int)descriptor_ptr->
type);
272 parameter_ptr = jackctl_add_parameter(
273 &driver_ptr->parameters,
274 descriptor_ptr->
name,
283 if (parameter_ptr == NULL)
288 parameter_ptr->driver_ptr = driver_ptr;
289 parameter_ptr->id = descriptor_ptr->
character;
295 jackctl_free_driver_parameters(driver_ptr);
302 jackctl_destroy_param_list(
320 jackctl_create_param_list(
327 *retparamlist = NULL;
328 while (paramlist != NULL)
331 if (param_ptr->is_set)
335 if (retparam_ptr == NULL)
337 jack_error (
"Allocation of jack_driver_param_t structure failed");
341 retparam_ptr->character = param_ptr->id;
343 switch (param_ptr->type)
346 retparam_ptr->value.i = param_ptr->value_ptr->
i;
349 retparam_ptr->value.ui = param_ptr->value_ptr->
ui;
352 retparam_ptr->value.c = param_ptr->value_ptr->
c;
355 strcpy(retparam_ptr->value.str, param_ptr->value_ptr->
str);
358 retparam_ptr->value.i = param_ptr->value_ptr->
b;
361 jack_error(
"Unknown parameter type %i", (
int)param_ptr->type);
366 *retparamlist = jack_slist_append(*retparamlist, retparam_ptr);
369 paramlist = paramlist->next;
377 jackctl_destroy_param_list(*retparamlist);
382 jackctl_drivers_load(
387 JSList *descriptor_node_ptr;
389 descriptor_node_ptr = jack_drivers_load(NULL);
390 if (descriptor_node_ptr == NULL)
392 jack_error(
"Could not find any drivers in driver directory!");
396 while (descriptor_node_ptr != NULL)
399 if (driver_ptr == NULL)
401 jack_error(
"Memory allocation of jackctl_driver structure failed.");
406 driver_ptr->parameters = NULL;
407 driver_ptr->infos = NULL;
409 if (!jackctl_add_driver_parameters(driver_ptr))
411 assert(driver_ptr->parameters == NULL);
416 server_ptr->drivers = jack_slist_append(server_ptr->drivers, driver_ptr);
419 node_ptr = descriptor_node_ptr;
420 descriptor_node_ptr = descriptor_node_ptr->next;
429 jackctl_server_free_drivers(
435 while (server_ptr->drivers)
437 next_node_ptr = server_ptr->drivers->next;
440 jackctl_free_driver_parameters(driver_ptr);
441 free(driver_ptr->desc_ptr->
params);
442 free(driver_ptr->desc_ptr);
445 free(server_ptr->drivers);
446 server_ptr->drivers = next_node_ptr;
451 jackctl_internals_load(
456 JSList *descriptor_node_ptr;
458 descriptor_node_ptr = jack_internals_load(NULL);
459 if (descriptor_node_ptr == NULL)
461 jack_error(
"Could not find any internals in driver directory!");
465 while (descriptor_node_ptr != NULL)
468 if (internal_ptr == NULL)
470 jack_error(
"Memory allocation of jackctl_driver structure failed.");
475 internal_ptr->parameters = NULL;
476 internal_ptr->refnum = -1;
478 if (!jackctl_add_driver_parameters((
struct jackctl_driver *)internal_ptr))
480 assert(internal_ptr->parameters == NULL);
485 server_ptr->internals = jack_slist_append(server_ptr->internals, internal_ptr);
488 node_ptr = descriptor_node_ptr;
489 descriptor_node_ptr = descriptor_node_ptr->next;
498 jackctl_server_free_internals(
504 while (server_ptr->internals)
506 next_node_ptr = server_ptr->internals->next;
509 jackctl_free_driver_parameters((
struct jackctl_driver *)internal_ptr);
510 free(internal_ptr->desc_ptr->
params);
511 free(internal_ptr->desc_ptr);
514 free(server_ptr->internals);
515 server_ptr->internals = next_node_ptr;
521 jackctl_server_free_parameters(
526 while (server_ptr->parameters)
528 next_node_ptr = server_ptr->parameters->next;
529 free(server_ptr->parameters->data);
530 free(server_ptr->parameters);
531 server_ptr->parameters = next_node_ptr;
544 static void signal_handler(
int signum)
546 printf(
"Jack main caught signal %d\n", signum);
547 (void) signal(SIGINT, SIG_DFL);
548 SetEvent(sigmask.wait_event);
555 if ((sigmask.wait_event = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
556 jack_error(
"CreateEvent fails err = %ld", GetLastError());
560 (void) signal(SIGINT, signal_handler);
561 (void) signal(SIGABRT, signal_handler);
562 (void) signal(SIGTERM, signal_handler);
569 if (WaitForSingleObject(signals->wait_event, INFINITE) != WAIT_OBJECT_0) {
570 jack_error(
"WaitForSingleObject fails err = %ld", GetLastError());
585 signal_handler(
int sig)
592 snprintf(buf,
sizeof(buf),
"Received signal %d during shutdown (ignored)\n", sig);
600 struct sigaction action;
609 pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
637 sigemptyset(&sigmask.signals);
638 sigaddset(&sigmask.signals, SIGHUP);
639 sigaddset(&sigmask.signals, SIGINT);
640 sigaddset(&sigmask.signals, SIGQUIT);
641 sigaddset(&sigmask.signals, SIGPIPE);
642 sigaddset(&sigmask.signals, SIGTERM);
647 sigaddset(&sigmask.signals, SIGUSR1);
649 sigaddset(&sigmask.signals, SIGUSR2);
655 pthread_sigmask(SIG_BLOCK, &sigmask.signals, 0);
661 sigfillset(&allsignals);
662 action.sa_handler = signal_handler;
663 action.sa_mask = allsignals;
664 action.sa_flags = SA_RESTART|SA_RESETHAND;
666 for (i = 1; i < NSIG; i++)
668 if (sigismember (&sigmask.signals, i))
670 sigaction(i, &action, 0);
684 #if defined(sun) && !defined(__sun__) // SUN compiler only, to check
685 sigwait(&sigmask->signals);
687 sigwait(&sigmask->signals, &sig);
689 fprintf(stderr,
"Jack main caught signal %d\n", sig);
707 if (sig != SIGSEGV) {
711 sigprocmask(SIG_UNBLOCK, &sigmask->signals, 0);
718 get_realtime_priority_constraint()
723 if (!jack_get_thread_realtime_priority_range(&min, &max))
731 if (constraint_ptr == NULL)
733 jack_error(
"Cannot allocate memory for jack_driver_param_constraint_desc_t structure.");
736 constraint_ptr->
flags = JACK_CONSTRAINT_FLAG_RANGE;
738 constraint_ptr->constraint.
range.min.i = min;
739 constraint_ptr->constraint.
range.max.i = max;
741 return constraint_ptr;
745 bool (* on_device_acquire)(
const char * device_name),
746 void (* on_device_release)(
const char * device_name))
752 if (server_ptr == NULL)
754 jack_error(
"Cannot allocate memory for jackctl_server structure.");
758 server_ptr->drivers = NULL;
759 server_ptr->internals = NULL;
760 server_ptr->parameters = NULL;
761 server_ptr->engine = NULL;
763 strcpy(value.
str, JackTools::DefaultServerName());
764 if (jackctl_add_parameter(
765 &server_ptr->parameters,
767 "Server name to use.",
771 &server_ptr->default_name,
774 goto fail_free_parameters;
778 if (jackctl_add_parameter(
779 &server_ptr->parameters,
781 "Whether to use realtime mode.",
782 "Use realtime scheduling. This is needed for reliable low-latency performance. On most systems, it requires JACK to run with special scheduler and memory allocation privileges, which may be obtained in several ways. On Linux you should use PAM.",
784 &server_ptr->realtime,
785 &server_ptr->default_realtime,
788 goto fail_free_parameters;
792 if (jackctl_add_parameter(
793 &server_ptr->parameters,
795 "Scheduler priority when running in realtime mode.",
798 &server_ptr->realtime_priority,
799 &server_ptr->default_realtime_priority,
801 get_realtime_priority_constraint()) == NULL)
803 goto fail_free_parameters;
807 if (jackctl_add_parameter(
808 &server_ptr->parameters,
810 "Exit once all clients have closed their connections.",
813 &server_ptr->temporary,
814 &server_ptr->default_temporary,
817 goto fail_free_parameters;
821 if (jackctl_add_parameter(
822 &server_ptr->parameters,
827 &server_ptr->verbose,
828 &server_ptr->default_verbose,
831 goto fail_free_parameters;
835 if (jackctl_add_parameter(
836 &server_ptr->parameters,
838 "Client timeout limit in milliseconds.",
841 &server_ptr->client_timeout,
842 &server_ptr->default_client_timeout,
845 goto fail_free_parameters;
849 if (jackctl_add_parameter(
850 &server_ptr->parameters,
852 "Clocksource type : c(ycle) | h(pet) | s(ystem).",
855 &server_ptr->clock_source,
856 &server_ptr->default_clock_source,
859 goto fail_free_parameters;
863 if (jackctl_add_parameter(
864 &server_ptr->parameters,
866 "Maximum number of ports.",
869 &server_ptr->port_max,
870 &server_ptr->default_port_max,
873 goto fail_free_parameters;
877 if (jackctl_add_parameter(
878 &server_ptr->parameters,
880 "Replace shared memory registry.",
883 &server_ptr->replace_registry,
884 &server_ptr->default_replace_registry,
887 goto fail_free_parameters;
891 if (jackctl_add_parameter(
892 &server_ptr->parameters,
894 "Use server synchronous mode.",
898 &server_ptr->default_sync,
901 goto fail_free_parameters;
904 value.
c = JACK_DEFAULT_SELF_CONNECT_MODE;
905 if (jackctl_add_parameter(
906 &server_ptr->parameters,
908 "Self connect mode.",
909 "Whether JACK clients are allowed to connect their own ports",
911 &server_ptr->self_connect_mode,
912 &server_ptr->default_self_connect_mode,
914 jack_constraint_compose_enum_char(
915 JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
916 self_connect_mode_constraint_descr_array)) == NULL)
918 goto fail_free_parameters;
921 JackServerGlobals::on_device_acquire = on_device_acquire;
922 JackServerGlobals::on_device_release = on_device_release;
924 if (!jackctl_drivers_load(server_ptr))
926 goto fail_free_parameters;
930 jackctl_internals_load(server_ptr);
934 fail_free_parameters:
935 jackctl_server_free_parameters(server_ptr);
946 jackctl_server_free_drivers(server_ptr);
947 jackctl_server_free_internals(server_ptr);
948 jackctl_server_free_parameters(server_ptr);
955 return (server_ptr) ? server_ptr->drivers : NULL;
961 server_ptr->engine->Stop();
971 server_ptr->engine->Close();
972 delete server_ptr->engine;
975 jack_log(
"Cleaning up shared memory");
981 JackTools::CleanupFiles(server_ptr->name.
str);
983 jack_log(
"Unregistering server `%s'", server_ptr->name.
str);
985 jack_unregister_server(server_ptr->name.
str);
987 server_ptr->engine = NULL;
997 return (server_ptr) ? server_ptr->parameters : NULL;
1005 JSList * paramlist = NULL;
1009 if (!server_ptr || !driver_ptr) {
1013 int rc = jack_register_server(server_ptr->name.
str, server_ptr->replace_registry.
b);
1017 jack_error(
"`%s' server already active", server_ptr->name.
str);
1020 jack_error(
"Too many servers already active");
1027 jack_log(
"Server `%s' registered", server_ptr->name.
str);
1032 JackTools::CleanupFiles(server_ptr->name.
str);
1034 if (!server_ptr->realtime.
b && server_ptr->client_timeout.
i == 0) {
1035 server_ptr->client_timeout.
i = 500;
1039 if (server_ptr->port_max.
ui > PORT_NUM_MAX) {
1040 jack_error(
"Jack server started with too much ports %d (when port max can be %d)", server_ptr->port_max.
ui, PORT_NUM_MAX);
1047 server_ptr->temporary.
b,
1048 server_ptr->client_timeout.
i,
1049 server_ptr->realtime.
b,
1050 server_ptr->realtime_priority.
i,
1051 server_ptr->port_max.
ui,
1052 server_ptr->verbose.
b,
1053 (jack_timer_type_t)server_ptr->clock_source.
ui,
1054 server_ptr->self_connect_mode.
c,
1055 server_ptr->name.
str);
1056 if (server_ptr->engine == NULL)
1058 jack_error(
"Failed to create new JackServer object");
1059 goto fail_unregister;
1062 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
goto fail_delete;
1063 rc = server_ptr->engine->Open(driver_ptr->desc_ptr, paramlist);
1064 jackctl_destroy_param_list(paramlist);
1067 jack_error(
"JackServer::Open failed with %d", rc);
1073 }
catch (std::exception e) {
1075 jackctl_destroy_param_list(paramlist);
1079 delete server_ptr->engine;
1080 server_ptr->engine = NULL;
1083 jack_log(
"Cleaning up shared memory");
1089 JackTools::CleanupFiles(server_ptr->name.
str);
1091 jack_log(
"Unregistering server `%s'", server_ptr->name.
str);
1093 jack_unregister_server(server_ptr->name.
str);
1106 int rc = server_ptr->engine->Start();
1107 bool result = rc >= 0;
1110 jack_error(
"JackServer::Start() failed with %d", rc);
1118 return (driver_ptr) ? driver_ptr->desc_ptr->
name : NULL;
1128 return (driver_ptr) ? driver_ptr->parameters : NULL;
1133 return (driver_ptr) ? driver_ptr->desc_ptr : NULL;
1138 return (parameter_ptr) ? parameter_ptr->name : NULL;
1143 return (parameter_ptr) ? parameter_ptr->short_description : NULL;
1148 return (parameter_ptr) ? parameter_ptr->long_description : NULL;
1153 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_RANGE) != 0) :
false;
1158 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_RANGE) == 0):
false;
1163 if (!parameter_ptr) {
1172 return parameter_ptr->constraint_ptr->constraint.
enumeration.count;
1180 if (!parameter_ptr) {
1181 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1182 return jackctl_value;
1185 value_ptr = ¶meter_ptr->constraint_ptr->constraint.enumeration.possible_values_array[index].value;
1187 switch (parameter_ptr->type)
1190 jackctl_value.
i = value_ptr->i;
1193 jackctl_value.
ui = value_ptr->ui;
1196 jackctl_value.
c = value_ptr->c;
1199 strcpy(jackctl_value.
str, value_ptr->str);
1202 jack_error(
"Bad driver parameter type %i (enum constraint)", (
int)parameter_ptr->type);
1206 return jackctl_value;
1211 return (parameter_ptr) ? parameter_ptr->constraint_ptr->constraint.
enumeration.possible_values_array[index].short_desc : NULL;
1216 if (!parameter_ptr || !min_ptr || !max_ptr) {
1220 switch (parameter_ptr->type)
1223 min_ptr->
i = parameter_ptr->constraint_ptr->constraint.
range.min.i;
1224 max_ptr->
i = parameter_ptr->constraint_ptr->constraint.
range.max.i;
1227 min_ptr->
ui = parameter_ptr->constraint_ptr->constraint.
range.min.ui;
1228 max_ptr->
ui = parameter_ptr->constraint_ptr->constraint.
range.max.ui;
1231 jack_error(
"Bad driver parameter type %i (range constraint)", (
int)parameter_ptr->type);
1238 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_STRICT) != 0) :
false;
1243 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_FAKE_VALUE) != 0) :
false;
1253 return (parameter_ptr) ? parameter_ptr->id : 0;
1258 return (parameter_ptr) ? parameter_ptr->is_set :
false;
1263 if (parameter_ptr) {
1264 return *parameter_ptr->value_ptr;
1267 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1268 return jackctl_value;
1274 if (!parameter_ptr) {
1278 if (!parameter_ptr->is_set)
1283 parameter_ptr->is_set =
false;
1285 *parameter_ptr->value_ptr = *parameter_ptr->default_value_ptr;
1292 if (!parameter_ptr || !value_ptr) {
1296 parameter_ptr->is_set =
true;
1297 *parameter_ptr->value_ptr = *value_ptr;
1304 if (parameter_ptr) {
1305 return *parameter_ptr->default_value_ptr;
1308 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1309 return jackctl_value;
1317 return (server_ptr) ? server_ptr->internals : NULL;
1322 return (internal_ptr) ? internal_ptr->desc_ptr->
name : NULL;
1327 return (internal_ptr) ? internal_ptr->parameters : NULL;
1334 if (!server_ptr || !
internal) {
1339 if (server_ptr->engine != NULL) {
1341 if (!jackctl_create_param_list(internal->parameters, ¶mlist))
return false;
1342 server_ptr->engine->InternalClientLoad2(internal->desc_ptr->name, internal->desc_ptr->name, paramlist, JackNullOption, &internal->refnum, -1, &status);
1343 jackctl_destroy_param_list(paramlist);
1344 return (internal->refnum > 0);
1354 if (!server_ptr || !
internal) {
1359 if (server_ptr->engine != NULL && internal->refnum > 0) {
1361 return ((server_ptr->engine->GetEngine()->InternalClientUnload(internal->refnum, &status)) == 0);
1369 if (server_ptr && server_ptr->engine) {
1370 if (server_ptr->engine->IsRunning()) {
1371 jack_error(
"Cannot add a slave in a running server");
1375 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
return false;
1376 JackDriverInfo* info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, paramlist);
1377 jackctl_destroy_param_list(paramlist);
1379 driver_ptr->infos = jack_slist_append(driver_ptr->infos, info);
1392 if (server_ptr && server_ptr->engine) {
1393 if (server_ptr->engine->IsRunning()) {
1394 jack_error(
"Cannot remove a slave from a running server");
1397 if (driver_ptr->infos) {
1400 driver_ptr->infos = jack_slist_remove(driver_ptr->infos, info);
1401 server_ptr->engine->RemoveSlave(info);
1415 if (server_ptr && server_ptr->engine) {
1417 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
return false;
1418 bool ret = (server_ptr->engine->SwitchMaster(driver_ptr->desc_ptr, paramlist) == 0);
1419 jackctl_destroy_param_list(paramlist);
SERVER_EXPORT const char * jackctl_parameter_get_long_description(jackctl_parameter *parameter_ptr)
value type is a signed integer
SERVER_EXPORT bool jackctl_parameter_is_set(jackctl_parameter *parameter_ptr)
SERVER_EXPORT union jackctl_parameter_value jackctl_parameter_get_value(jackctl_parameter *parameter_ptr)
SERVER_EXPORT jackctl_sigmask_t * jackctl_setup_signals(unsigned int flags)
char str[JACK_PARAM_STRING_MAX+1]
member used for JackParamString
SERVER_EXPORT union jackctl_parameter_value jackctl_parameter_get_default_value(jackctl_parameter *parameter_ptr)
value type is an unsigned integer
SERVER_EXPORT bool jackctl_server_open(jackctl_server *server_ptr, jackctl_driver *driver_ptr)
SERVER_EXPORT void jackctl_parameter_get_range_constraint(jackctl_parameter *parameter_ptr, union jackctl_parameter_value *min_ptr, union jackctl_parameter_value *max_ptr)
SERVER_EXPORT void jack_error(const char *fmt,...)
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_parameter_reset(jackctl_parameter *parameter_ptr)
uint32_t ui
member used for JackParamUInt
jack_driver_param_value_t value
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)
int32_t i
member used for JackParamInt
SERVER_EXPORT const char * jackctl_parameter_get_name(jackctl_parameter *parameter_ptr)
SERVER_EXPORT bool jackctl_server_stop(jackctl_server *server_ptr)
bool b
member used for JackParamBool
Type for parameter value.
SERVER_EXPORT const JSList * jackctl_driver_get_parameters(jackctl_driver *driver_ptr)
value type is a string with max size of JACK_PARAM_STRING_MAX+1 chars
SERVER_EXPORT bool jackctl_parameter_has_range_constraint(jackctl_parameter *parameter_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)
jack_driver_param_constraint_desc_t * constraint
SERVER_EXPORT const char * jackctl_parameter_get_short_description(jackctl_parameter *parameter_ptr)
SERVER_EXPORT bool jackctl_parameter_constraint_is_fake_value(jackctl_parameter_t *parameter_ptr)
struct jack_driver_param_constraint_desc_t::@0::@1 range
SERVER_EXPORT jackctl_param_type_t jackctl_parameter_get_type(jackctl_parameter *parameter_ptr)
SERVER_EXPORT const JSList * jackctl_server_get_drivers_list(jackctl_server *server_ptr)
char name[JACK_DRIVER_NAME_MAX+1]
char name[JACK_DRIVER_NAME_MAX+1]
SERVER_EXPORT bool jackctl_server_start(jackctl_server *server_ptr)
SERVER_EXPORT bool jackctl_parameter_constraint_is_strict(jackctl_parameter_t *parameter_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)
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)
SERVER_EXPORT bool jackctl_server_unload_internal(jackctl_server *server_ptr, jackctl_internal *internal)
jack_driver_param_type_t type
SERVER_EXPORT char jackctl_parameter_get_id(jackctl_parameter_t *parameter_ptr)
SERVER_EXPORT const JSList * jackctl_internal_get_parameters(jackctl_internal *internal_ptr)
struct jack_driver_param_constraint_desc_t::@0::@2 enumeration
SERVER_EXPORT void jackctl_server_destroy(jackctl_server *server_ptr)
SERVER_EXPORT jackctl_driver_type_t jackctl_driver_get_type(jackctl_driver *driver_ptr)
char c
member used for JackParamChar
SERVER_EXPORT const JSList * jackctl_server_get_parameters(jackctl_server *server_ptr)
SERVER_EXPORT bool jackctl_parameter_has_enum_constraint(jackctl_parameter *parameter_ptr)
SERVER_EXPORT void jackctl_wait_signals(jackctl_sigmask_t *sigmask)
SERVER_EXPORT void jack_log(const char *fmt,...)
SERVER_EXPORT bool jackctl_server_load_internal(jackctl_server *server_ptr, jackctl_internal *internal)
jack_driver_param_desc_t * params