35 #include <sys/utsname.h> 38 #include "driver_interface.h" 39 #include "JackError.h" 40 #include "JackServer.h" 42 #include "JackTools.h" 43 #include "JackControlAPI.h" 44 #include "JackLockedEngine.h" 45 #include "JackConstants.h" 46 #include "JackDriverLoader.h" 47 #include "JackServerGlobals.h" 54 {
' ',
"Don't restrict self connect requests" },
55 {
'E',
"Fail self connect requests to external ports only" },
56 {
'e',
"Ignore self connect requests to external ports only" },
57 {
'A',
"Fail all self connect requests" },
58 {
'a',
"Ignore all self connect requests" },
132 const char * short_description;
133 const char * long_description;
134 jackctl_param_type_t type;
146 const char * jack_get_self_connect_mode_description(
char mode)
150 for (descr_ptr = self_connect_mode_constraint_descr_array;
153 if (descr_ptr->value == mode)
return descr_ptr->short_desc;
160 jackctl_add_parameter(
161 JSList ** parameters_list_ptr_ptr,
163 const char * short_description,
164 const char * long_description,
165 jackctl_param_type_t type,
174 if (parameter_ptr == NULL)
176 jack_error(
"Cannot allocate memory for jackctl_parameter structure.");
180 parameter_ptr->name = name;
181 parameter_ptr->short_description = short_description;
182 parameter_ptr->long_description = long_description;
183 parameter_ptr->type = type;
184 parameter_ptr->is_set =
false;
186 if (value_ptr == NULL)
188 value_ptr = ¶meter_ptr->value;
191 if (default_value_ptr == NULL)
193 default_value_ptr = ¶meter_ptr->default_value;
196 parameter_ptr->value_ptr = value_ptr;
197 parameter_ptr->default_value_ptr = default_value_ptr;
199 *value_ptr = *default_value_ptr = value;
201 parameter_ptr->driver_ptr = NULL;
202 parameter_ptr->id = 0;
203 parameter_ptr->constraint_ptr = constraint_ptr;
205 *parameters_list_ptr_ptr = jack_slist_append(*parameters_list_ptr_ptr, parameter_ptr);
207 return parameter_ptr;
215 jackctl_free_driver_parameters(
220 while (driver_ptr->parameters)
222 next_node_ptr = driver_ptr->parameters->next;
223 free(driver_ptr->parameters->data);
224 free(driver_ptr->parameters);
225 driver_ptr->parameters = next_node_ptr;
231 jackctl_add_driver_parameters(
237 jackctl_param_type_t jackctl_type;
241 for (i = 0 ; i < driver_ptr->desc_ptr->
nparams ; i++)
243 descriptor_ptr = driver_ptr->desc_ptr->
params + i;
245 switch (descriptor_ptr->
type)
247 case JackDriverParamInt:
249 jackctl_value.
i = descriptor_ptr->
value.i;
251 case JackDriverParamUInt:
253 jackctl_value.
ui = descriptor_ptr->
value.ui;
255 case JackDriverParamChar:
257 jackctl_value.
c = descriptor_ptr->
value.c;
259 case JackDriverParamString:
261 strcpy(jackctl_value.
str, descriptor_ptr->
value.str);
263 case JackDriverParamBool:
265 jackctl_value.
b = descriptor_ptr->
value.i;
268 jack_error(
"Unknown driver parameter type %i", (
int)descriptor_ptr->
type);
273 parameter_ptr = jackctl_add_parameter(
274 &driver_ptr->parameters,
275 descriptor_ptr->
name,
284 if (parameter_ptr == NULL)
289 parameter_ptr->driver_ptr = driver_ptr;
290 parameter_ptr->id = descriptor_ptr->
character;
296 jackctl_free_driver_parameters(driver_ptr);
303 jackctl_destroy_param_list(
321 jackctl_create_param_list(
328 *retparamlist = NULL;
329 while (paramlist != NULL)
332 if (param_ptr->is_set)
336 if (retparam_ptr == NULL)
338 jack_error (
"Allocation of jack_driver_param_t structure failed");
342 retparam_ptr->character = param_ptr->id;
344 switch (param_ptr->type)
347 retparam_ptr->value.i = param_ptr->value_ptr->
i;
350 retparam_ptr->value.ui = param_ptr->value_ptr->
ui;
353 retparam_ptr->value.c = param_ptr->value_ptr->
c;
356 strcpy(retparam_ptr->value.str, param_ptr->value_ptr->
str);
359 retparam_ptr->value.i = param_ptr->value_ptr->
b;
362 jack_error(
"Unknown parameter type %i", (
int)param_ptr->type);
367 *retparamlist = jack_slist_append(*retparamlist, retparam_ptr);
370 paramlist = paramlist->next;
378 jackctl_destroy_param_list(*retparamlist);
383 jackctl_drivers_load(
388 JSList *descriptor_node_ptr;
390 descriptor_node_ptr = jack_drivers_load(NULL);
391 if (descriptor_node_ptr == NULL)
393 jack_error(
"Could not find any drivers in driver directory!");
397 while (descriptor_node_ptr != NULL)
400 if (driver_ptr == NULL)
402 jack_error(
"Memory allocation of jackctl_driver structure failed.");
407 driver_ptr->parameters = NULL;
408 driver_ptr->infos = NULL;
410 if (!jackctl_add_driver_parameters(driver_ptr))
412 assert(driver_ptr->parameters == NULL);
417 server_ptr->drivers = jack_slist_append(server_ptr->drivers, driver_ptr);
420 node_ptr = descriptor_node_ptr;
421 descriptor_node_ptr = descriptor_node_ptr->next;
430 jackctl_server_free_drivers(
436 while (server_ptr->drivers)
438 next_node_ptr = server_ptr->drivers->next;
441 jackctl_free_driver_parameters(driver_ptr);
442 free(driver_ptr->desc_ptr->
params);
443 free(driver_ptr->desc_ptr);
446 free(server_ptr->drivers);
447 server_ptr->drivers = next_node_ptr;
452 jackctl_internals_load(
457 JSList *descriptor_node_ptr;
459 descriptor_node_ptr = jack_internals_load(NULL);
460 if (descriptor_node_ptr == NULL)
462 jack_error(
"Could not find any internals in driver directory!");
466 while (descriptor_node_ptr != NULL)
469 if (internal_ptr == NULL)
471 jack_error(
"Memory allocation of jackctl_driver structure failed.");
476 internal_ptr->parameters = NULL;
477 internal_ptr->refnum = -1;
479 if (!jackctl_add_driver_parameters((
struct jackctl_driver *)internal_ptr))
481 assert(internal_ptr->parameters == NULL);
486 server_ptr->internals = jack_slist_append(server_ptr->internals, internal_ptr);
489 node_ptr = descriptor_node_ptr;
490 descriptor_node_ptr = descriptor_node_ptr->next;
499 jackctl_server_free_internals(
505 while (server_ptr->internals)
507 next_node_ptr = server_ptr->internals->next;
510 jackctl_free_driver_parameters((
struct jackctl_driver *)internal_ptr);
511 free(internal_ptr->desc_ptr->
params);
512 free(internal_ptr->desc_ptr);
515 free(server_ptr->internals);
516 server_ptr->internals = next_node_ptr;
522 jackctl_server_free_parameters(
527 while (server_ptr->parameters)
529 next_node_ptr = server_ptr->parameters->next;
530 free(server_ptr->parameters->data);
531 free(server_ptr->parameters);
532 server_ptr->parameters = next_node_ptr;
545 static void signal_handler(
int signum)
547 printf(
"Jack main caught signal %d\n", signum);
548 (void) signal(SIGINT, SIG_DFL);
549 SetEvent(sigmask.wait_event);
556 if ((sigmask.wait_event = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
557 jack_error(
"CreateEvent fails err = %ld", GetLastError());
561 (void) signal(SIGINT, signal_handler);
562 (void) signal(SIGABRT, signal_handler);
563 (void) signal(SIGTERM, signal_handler);
570 if (WaitForSingleObject(signals->wait_event, INFINITE) != WAIT_OBJECT_0) {
571 jack_error(
"WaitForSingleObject fails err = %ld", GetLastError());
586 signal_handler(
int sig)
593 snprintf(buf,
sizeof(buf),
"Received signal %d during shutdown (ignored)\n", sig);
601 struct sigaction action;
610 pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
638 sigemptyset(&sigmask.signals);
639 sigaddset(&sigmask.signals, SIGHUP);
640 sigaddset(&sigmask.signals, SIGINT);
641 sigaddset(&sigmask.signals, SIGQUIT);
642 sigaddset(&sigmask.signals, SIGPIPE);
643 sigaddset(&sigmask.signals, SIGTERM);
648 sigaddset(&sigmask.signals, SIGUSR1);
650 sigaddset(&sigmask.signals, SIGUSR2);
656 pthread_sigmask(SIG_BLOCK, &sigmask.signals, 0);
662 sigfillset(&allsignals);
663 action.sa_handler = signal_handler;
664 action.sa_mask = allsignals;
665 action.sa_flags = SA_RESTART|SA_RESETHAND;
667 for (i = 1; i < NSIG; i++)
669 if (sigismember (&sigmask.signals, i))
671 sigaction(i, &action, 0);
685 #if defined(sun) && !defined(__sun__) // SUN compiler only, to check 686 sigwait(&sigmask->signals);
688 sigwait(&sigmask->signals, &sig);
690 fprintf(stderr,
"Jack main caught signal %d\n", sig);
708 if (sig != SIGSEGV) {
712 sigprocmask(SIG_UNBLOCK, &sigmask->signals, 0);
719 get_realtime_priority_constraint()
724 if (!jack_get_thread_realtime_priority_range(&min, &max))
732 if (constraint_ptr == NULL)
734 jack_error(
"Cannot allocate memory for jack_driver_param_constraint_desc_t structure.");
737 constraint_ptr->
flags = JACK_CONSTRAINT_FLAG_RANGE;
739 constraint_ptr->constraint.
range.min.i = min;
740 constraint_ptr->constraint.
range.max.i = max;
742 return constraint_ptr;
746 bool (* on_device_acquire)(
const char * device_name),
747 void (* on_device_release)(
const char * device_name))
753 if (server_ptr == NULL)
755 jack_error(
"Cannot allocate memory for jackctl_server structure.");
759 server_ptr->drivers = NULL;
760 server_ptr->internals = NULL;
761 server_ptr->parameters = NULL;
762 server_ptr->engine = NULL;
764 strcpy(value.
str, JackTools::DefaultServerName());
765 if (jackctl_add_parameter(
766 &server_ptr->parameters,
768 "Server name to use.",
772 &server_ptr->default_name,
775 goto fail_free_parameters;
779 if (jackctl_add_parameter(
780 &server_ptr->parameters,
782 "Whether to use realtime mode.",
783 "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.",
785 &server_ptr->realtime,
786 &server_ptr->default_realtime,
789 goto fail_free_parameters;
792 struct utsname utsname;
794 success = uname( &utsname );
795 if( success == 0 && strstr( utsname.version,
"PREEMPT RT" ) )
800 if (jackctl_add_parameter(
801 &server_ptr->parameters,
803 "Scheduler priority when running in realtime mode.",
806 &server_ptr->realtime_priority,
807 &server_ptr->default_realtime_priority,
809 get_realtime_priority_constraint()) == NULL)
811 goto fail_free_parameters;
815 if (jackctl_add_parameter(
816 &server_ptr->parameters,
818 "Exit once all clients have closed their connections.",
821 &server_ptr->temporary,
822 &server_ptr->default_temporary,
825 goto fail_free_parameters;
829 if (jackctl_add_parameter(
830 &server_ptr->parameters,
835 &server_ptr->verbose,
836 &server_ptr->default_verbose,
839 goto fail_free_parameters;
843 if (jackctl_add_parameter(
844 &server_ptr->parameters,
846 "Client timeout limit in milliseconds.",
849 &server_ptr->client_timeout,
850 &server_ptr->default_client_timeout,
853 goto fail_free_parameters;
857 if (jackctl_add_parameter(
858 &server_ptr->parameters,
860 "Clocksource type : c(ycle) | h(pet) | s(ystem).",
863 &server_ptr->clock_source,
864 &server_ptr->default_clock_source,
867 goto fail_free_parameters;
871 if (jackctl_add_parameter(
872 &server_ptr->parameters,
874 "Maximum number of ports.",
877 &server_ptr->port_max,
878 &server_ptr->default_port_max,
881 goto fail_free_parameters;
885 if (jackctl_add_parameter(
886 &server_ptr->parameters,
888 "Replace shared memory registry.",
891 &server_ptr->replace_registry,
892 &server_ptr->default_replace_registry,
895 goto fail_free_parameters;
899 if (jackctl_add_parameter(
900 &server_ptr->parameters,
902 "Use server synchronous mode.",
906 &server_ptr->default_sync,
909 goto fail_free_parameters;
912 value.
c = JACK_DEFAULT_SELF_CONNECT_MODE;
913 if (jackctl_add_parameter(
914 &server_ptr->parameters,
916 "Self connect mode.",
917 "Whether JACK clients are allowed to connect their own ports",
919 &server_ptr->self_connect_mode,
920 &server_ptr->default_self_connect_mode,
922 jack_constraint_compose_enum_char(
923 JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
924 self_connect_mode_constraint_descr_array)) == NULL)
926 goto fail_free_parameters;
929 JackServerGlobals::on_device_acquire = on_device_acquire;
930 JackServerGlobals::on_device_release = on_device_release;
932 if (!jackctl_drivers_load(server_ptr))
934 goto fail_free_parameters;
938 jackctl_internals_load(server_ptr);
942 fail_free_parameters:
943 jackctl_server_free_parameters(server_ptr);
954 jackctl_server_free_drivers(server_ptr);
955 jackctl_server_free_internals(server_ptr);
956 jackctl_server_free_parameters(server_ptr);
963 return (server_ptr) ? server_ptr->drivers : NULL;
969 server_ptr->engine->Stop();
979 server_ptr->engine->Close();
980 delete server_ptr->engine;
983 jack_log(
"Cleaning up shared memory");
989 JackTools::CleanupFiles(server_ptr->name.
str);
991 jack_log(
"Unregistering server `%s'", server_ptr->name.
str);
993 jack_unregister_server(server_ptr->name.
str);
995 server_ptr->engine = NULL;
1005 return (server_ptr) ? server_ptr->parameters : NULL;
1013 JSList * paramlist = NULL;
1017 if (!server_ptr || !driver_ptr) {
1021 int rc = jack_register_server(server_ptr->name.
str, server_ptr->replace_registry.
b);
1025 jack_error(
"`%s' server already active", server_ptr->name.
str);
1028 jack_error(
"Too many servers already active");
1035 jack_log(
"Server `%s' registered", server_ptr->name.
str);
1040 JackTools::CleanupFiles(server_ptr->name.
str);
1042 if (!server_ptr->realtime.
b && server_ptr->client_timeout.
i == 0) {
1043 server_ptr->client_timeout.
i = 500;
1047 if (server_ptr->port_max.
ui > PORT_NUM_MAX) {
1048 jack_error(
"Jack server started with too much ports %d (when port max can be %d)", server_ptr->port_max.
ui, PORT_NUM_MAX);
1055 server_ptr->temporary.
b,
1056 server_ptr->client_timeout.
i,
1057 server_ptr->realtime.
b,
1058 server_ptr->realtime_priority.
i,
1059 server_ptr->port_max.
ui,
1060 server_ptr->verbose.
b,
1061 (jack_timer_type_t)server_ptr->clock_source.
ui,
1062 server_ptr->self_connect_mode.
c,
1063 server_ptr->name.
str);
1064 if (server_ptr->engine == NULL)
1066 jack_error(
"Failed to create new JackServer object");
1067 goto fail_unregister;
1070 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
goto fail_delete;
1071 rc = server_ptr->engine->Open(driver_ptr->desc_ptr, paramlist);
1072 jackctl_destroy_param_list(paramlist);
1075 jack_error(
"JackServer::Open failed with %d", rc);
1081 }
catch (std::exception e) {
1083 jackctl_destroy_param_list(paramlist);
1087 delete server_ptr->engine;
1088 server_ptr->engine = NULL;
1091 jack_log(
"Cleaning up shared memory");
1097 JackTools::CleanupFiles(server_ptr->name.
str);
1099 jack_log(
"Unregistering server `%s'", server_ptr->name.
str);
1101 jack_unregister_server(server_ptr->name.
str);
1114 int rc = server_ptr->engine->Start();
1115 bool result = rc >= 0;
1118 jack_error(
"JackServer::Start() failed with %d", rc);
1126 return (driver_ptr) ? driver_ptr->desc_ptr->
name : NULL;
1136 return (driver_ptr) ? driver_ptr->parameters : NULL;
1141 return (driver_ptr) ? driver_ptr->desc_ptr : NULL;
1146 return (parameter_ptr) ? parameter_ptr->name : NULL;
1151 return (parameter_ptr) ? parameter_ptr->short_description : NULL;
1156 return (parameter_ptr) ? parameter_ptr->long_description : NULL;
1161 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_RANGE) != 0) :
false;
1166 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_RANGE) == 0):
false;
1171 if (!parameter_ptr) {
1180 return parameter_ptr->constraint_ptr->constraint.
enumeration.count;
1188 if (!parameter_ptr) {
1189 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1190 return jackctl_value;
1193 value_ptr = ¶meter_ptr->constraint_ptr->constraint.enumeration.possible_values_array[index].value;
1195 switch (parameter_ptr->type)
1198 jackctl_value.
i = value_ptr->i;
1201 jackctl_value.
ui = value_ptr->ui;
1204 jackctl_value.
c = value_ptr->c;
1207 strcpy(jackctl_value.
str, value_ptr->str);
1210 jack_error(
"Bad driver parameter type %i (enum constraint)", (
int)parameter_ptr->type);
1214 return jackctl_value;
1219 return (parameter_ptr) ? parameter_ptr->constraint_ptr->constraint.
enumeration.possible_values_array[index].short_desc : NULL;
1224 if (!parameter_ptr || !min_ptr || !max_ptr) {
1228 switch (parameter_ptr->type)
1231 min_ptr->
i = parameter_ptr->constraint_ptr->constraint.
range.min.i;
1232 max_ptr->
i = parameter_ptr->constraint_ptr->constraint.
range.max.i;
1235 min_ptr->
ui = parameter_ptr->constraint_ptr->constraint.
range.min.ui;
1236 max_ptr->
ui = parameter_ptr->constraint_ptr->constraint.
range.max.ui;
1239 jack_error(
"Bad driver parameter type %i (range constraint)", (
int)parameter_ptr->type);
1246 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_STRICT) != 0) :
false;
1251 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_FAKE_VALUE) != 0) :
false;
1261 return (parameter_ptr) ? parameter_ptr->id : 0;
1266 return (parameter_ptr) ? parameter_ptr->is_set :
false;
1271 if (parameter_ptr) {
1272 return *parameter_ptr->value_ptr;
1275 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1276 return jackctl_value;
1282 if (!parameter_ptr) {
1286 if (!parameter_ptr->is_set)
1291 parameter_ptr->is_set =
false;
1293 *parameter_ptr->value_ptr = *parameter_ptr->default_value_ptr;
1300 if (!parameter_ptr || !value_ptr) {
1304 parameter_ptr->is_set =
true;
1305 *parameter_ptr->value_ptr = *value_ptr;
1312 if (parameter_ptr) {
1313 return *parameter_ptr->default_value_ptr;
1316 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1317 return jackctl_value;
1325 return (server_ptr) ? server_ptr->internals : NULL;
1330 return (internal_ptr) ? internal_ptr->desc_ptr->
name : NULL;
1335 return (internal_ptr) ? internal_ptr->parameters : NULL;
1342 if (!server_ptr || !
internal) {
1347 if (server_ptr->engine != NULL) {
1349 if (!jackctl_create_param_list(internal->parameters, ¶mlist))
return false;
1350 server_ptr->engine->InternalClientLoad2(internal->desc_ptr->name, internal->desc_ptr->name, paramlist, JackNullOption, &internal->refnum, -1, &status);
1351 jackctl_destroy_param_list(paramlist);
1352 return (internal->refnum > 0);
1362 if (!server_ptr || !
internal) {
1367 if (server_ptr->engine != NULL && internal->refnum > 0) {
1369 return ((server_ptr->engine->GetEngine()->InternalClientUnload(internal->refnum, &status)) == 0);
1377 if (server_ptr && server_ptr->engine) {
1378 if (server_ptr->engine->IsRunning()) {
1379 jack_error(
"Cannot add a slave in a running server");
1383 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
return false;
1384 JackDriverInfo* info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, paramlist);
1385 jackctl_destroy_param_list(paramlist);
1387 driver_ptr->infos = jack_slist_append(driver_ptr->infos, info);
1400 if (server_ptr && server_ptr->engine) {
1401 if (server_ptr->engine->IsRunning()) {
1402 jack_error(
"Cannot remove a slave from a running server");
1405 if (driver_ptr->infos) {
1408 driver_ptr->infos = jack_slist_remove(driver_ptr->infos, info);
1409 server_ptr->engine->RemoveSlave(info);
1423 if (server_ptr && server_ptr->engine) {
1425 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
return false;
1426 bool ret = (server_ptr->engine->SwitchMaster(driver_ptr->desc_ptr, paramlist) == 0);
1427 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