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,
"ccrma" ) )
799 if (jackctl_add_parameter(
800 &server_ptr->parameters,
802 "Scheduler priority when running in realtime mode.",
805 &server_ptr->realtime_priority,
806 &server_ptr->default_realtime_priority,
808 get_realtime_priority_constraint()) == NULL)
810 goto fail_free_parameters;
814 if (jackctl_add_parameter(
815 &server_ptr->parameters,
817 "Exit once all clients have closed their connections.",
820 &server_ptr->temporary,
821 &server_ptr->default_temporary,
824 goto fail_free_parameters;
828 if (jackctl_add_parameter(
829 &server_ptr->parameters,
834 &server_ptr->verbose,
835 &server_ptr->default_verbose,
838 goto fail_free_parameters;
842 if (jackctl_add_parameter(
843 &server_ptr->parameters,
845 "Client timeout limit in milliseconds.",
848 &server_ptr->client_timeout,
849 &server_ptr->default_client_timeout,
852 goto fail_free_parameters;
856 if (jackctl_add_parameter(
857 &server_ptr->parameters,
859 "Clocksource type : c(ycle) | h(pet) | s(ystem).",
862 &server_ptr->clock_source,
863 &server_ptr->default_clock_source,
866 goto fail_free_parameters;
870 if (jackctl_add_parameter(
871 &server_ptr->parameters,
873 "Maximum number of ports.",
876 &server_ptr->port_max,
877 &server_ptr->default_port_max,
880 goto fail_free_parameters;
884 if (jackctl_add_parameter(
885 &server_ptr->parameters,
887 "Replace shared memory registry.",
890 &server_ptr->replace_registry,
891 &server_ptr->default_replace_registry,
894 goto fail_free_parameters;
898 if (jackctl_add_parameter(
899 &server_ptr->parameters,
901 "Use server synchronous mode.",
905 &server_ptr->default_sync,
908 goto fail_free_parameters;
911 value.
c = JACK_DEFAULT_SELF_CONNECT_MODE;
912 if (jackctl_add_parameter(
913 &server_ptr->parameters,
915 "Self connect mode.",
916 "Whether JACK clients are allowed to connect their own ports",
918 &server_ptr->self_connect_mode,
919 &server_ptr->default_self_connect_mode,
921 jack_constraint_compose_enum_char(
922 JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
923 self_connect_mode_constraint_descr_array)) == NULL)
925 goto fail_free_parameters;
928 JackServerGlobals::on_device_acquire = on_device_acquire;
929 JackServerGlobals::on_device_release = on_device_release;
931 if (!jackctl_drivers_load(server_ptr))
933 goto fail_free_parameters;
937 jackctl_internals_load(server_ptr);
941 fail_free_parameters:
942 jackctl_server_free_parameters(server_ptr);
953 jackctl_server_free_drivers(server_ptr);
954 jackctl_server_free_internals(server_ptr);
955 jackctl_server_free_parameters(server_ptr);
962 return (server_ptr) ? server_ptr->drivers : NULL;
968 server_ptr->engine->Stop();
978 server_ptr->engine->Close();
979 delete server_ptr->engine;
982 jack_log(
"Cleaning up shared memory");
988 JackTools::CleanupFiles(server_ptr->name.
str);
990 jack_log(
"Unregistering server `%s'", server_ptr->name.
str);
992 jack_unregister_server(server_ptr->name.
str);
994 server_ptr->engine = NULL;
1004 return (server_ptr) ? server_ptr->parameters : NULL;
1012 JSList * paramlist = NULL;
1016 if (!server_ptr || !driver_ptr) {
1020 int rc = jack_register_server(server_ptr->name.
str, server_ptr->replace_registry.
b);
1024 jack_error(
"`%s' server already active", server_ptr->name.
str);
1027 jack_error(
"Too many servers already active");
1034 jack_log(
"Server `%s' registered", server_ptr->name.
str);
1039 JackTools::CleanupFiles(server_ptr->name.
str);
1041 if (!server_ptr->realtime.
b && server_ptr->client_timeout.
i == 0) {
1042 server_ptr->client_timeout.
i = 500;
1046 if (server_ptr->port_max.
ui > PORT_NUM_MAX) {
1047 jack_error(
"Jack server started with too much ports %d (when port max can be %d)", server_ptr->port_max.
ui, PORT_NUM_MAX);
1054 server_ptr->temporary.
b,
1055 server_ptr->client_timeout.
i,
1056 server_ptr->realtime.
b,
1057 server_ptr->realtime_priority.
i,
1058 server_ptr->port_max.
ui,
1059 server_ptr->verbose.
b,
1060 (jack_timer_type_t)server_ptr->clock_source.
ui,
1061 server_ptr->self_connect_mode.
c,
1062 server_ptr->name.
str);
1063 if (server_ptr->engine == NULL)
1065 jack_error(
"Failed to create new JackServer object");
1066 goto fail_unregister;
1069 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
goto fail_delete;
1070 rc = server_ptr->engine->Open(driver_ptr->desc_ptr, paramlist);
1071 jackctl_destroy_param_list(paramlist);
1074 jack_error(
"JackServer::Open failed with %d", rc);
1080 }
catch (std::exception e) {
1082 jackctl_destroy_param_list(paramlist);
1086 delete server_ptr->engine;
1087 server_ptr->engine = NULL;
1090 jack_log(
"Cleaning up shared memory");
1096 JackTools::CleanupFiles(server_ptr->name.
str);
1098 jack_log(
"Unregistering server `%s'", server_ptr->name.
str);
1100 jack_unregister_server(server_ptr->name.
str);
1113 int rc = server_ptr->engine->Start();
1114 bool result = rc >= 0;
1117 jack_error(
"JackServer::Start() failed with %d", rc);
1125 return (driver_ptr) ? driver_ptr->desc_ptr->
name : NULL;
1135 return (driver_ptr) ? driver_ptr->parameters : NULL;
1140 return (driver_ptr) ? driver_ptr->desc_ptr : NULL;
1145 return (parameter_ptr) ? parameter_ptr->name : NULL;
1150 return (parameter_ptr) ? parameter_ptr->short_description : NULL;
1155 return (parameter_ptr) ? parameter_ptr->long_description : NULL;
1160 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_RANGE) != 0) :
false;
1165 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_RANGE) == 0):
false;
1170 if (!parameter_ptr) {
1179 return parameter_ptr->constraint_ptr->constraint.
enumeration.count;
1187 if (!parameter_ptr) {
1188 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1189 return jackctl_value;
1192 value_ptr = ¶meter_ptr->constraint_ptr->constraint.enumeration.possible_values_array[index].value;
1194 switch (parameter_ptr->type)
1197 jackctl_value.
i = value_ptr->i;
1200 jackctl_value.
ui = value_ptr->ui;
1203 jackctl_value.
c = value_ptr->c;
1206 strcpy(jackctl_value.
str, value_ptr->str);
1209 jack_error(
"Bad driver parameter type %i (enum constraint)", (
int)parameter_ptr->type);
1213 return jackctl_value;
1218 return (parameter_ptr) ? parameter_ptr->constraint_ptr->constraint.
enumeration.possible_values_array[index].short_desc : NULL;
1223 if (!parameter_ptr || !min_ptr || !max_ptr) {
1227 switch (parameter_ptr->type)
1230 min_ptr->
i = parameter_ptr->constraint_ptr->constraint.
range.min.i;
1231 max_ptr->
i = parameter_ptr->constraint_ptr->constraint.
range.max.i;
1234 min_ptr->
ui = parameter_ptr->constraint_ptr->constraint.
range.min.ui;
1235 max_ptr->
ui = parameter_ptr->constraint_ptr->constraint.
range.max.ui;
1238 jack_error(
"Bad driver parameter type %i (range constraint)", (
int)parameter_ptr->type);
1245 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_STRICT) != 0) :
false;
1250 return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->
flags & JACK_CONSTRAINT_FLAG_FAKE_VALUE) != 0) :
false;
1260 return (parameter_ptr) ? parameter_ptr->id : 0;
1265 return (parameter_ptr) ? parameter_ptr->is_set :
false;
1270 if (parameter_ptr) {
1271 return *parameter_ptr->value_ptr;
1274 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1275 return jackctl_value;
1281 if (!parameter_ptr) {
1285 if (!parameter_ptr->is_set)
1290 parameter_ptr->is_set =
false;
1292 *parameter_ptr->value_ptr = *parameter_ptr->default_value_ptr;
1299 if (!parameter_ptr || !value_ptr) {
1303 parameter_ptr->is_set =
true;
1304 *parameter_ptr->value_ptr = *value_ptr;
1311 if (parameter_ptr) {
1312 return *parameter_ptr->default_value_ptr;
1315 memset(&jackctl_value, 0,
sizeof(jackctl_value));
1316 return jackctl_value;
1324 return (server_ptr) ? server_ptr->internals : NULL;
1329 return (internal_ptr) ? internal_ptr->desc_ptr->
name : NULL;
1334 return (internal_ptr) ? internal_ptr->parameters : NULL;
1341 if (!server_ptr || !
internal) {
1346 if (server_ptr->engine != NULL) {
1348 if (!jackctl_create_param_list(internal->parameters, ¶mlist))
return false;
1349 server_ptr->engine->InternalClientLoad2(internal->desc_ptr->name, internal->desc_ptr->name, paramlist, JackNullOption, &internal->refnum, -1, &status);
1350 jackctl_destroy_param_list(paramlist);
1351 return (internal->refnum > 0);
1361 if (!server_ptr || !
internal) {
1366 if (server_ptr->engine != NULL && internal->refnum > 0) {
1368 return ((server_ptr->engine->GetEngine()->InternalClientUnload(internal->refnum, &status)) == 0);
1378 if (!server_ptr || !file || !server_ptr->engine) {
1382 return (server_ptr->engine->LoadInternalSessionFile(file) >= 0);
1387 if (server_ptr && server_ptr->engine) {
1388 if (server_ptr->engine->IsRunning()) {
1389 jack_error(
"Cannot add a slave in a running server");
1393 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
return false;
1394 JackDriverInfo* info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, paramlist);
1395 jackctl_destroy_param_list(paramlist);
1397 driver_ptr->infos = jack_slist_append(driver_ptr->infos, info);
1410 if (server_ptr && server_ptr->engine) {
1411 if (server_ptr->engine->IsRunning()) {
1412 jack_error(
"Cannot remove a slave from a running server");
1415 if (driver_ptr->infos) {
1418 driver_ptr->infos = jack_slist_remove(driver_ptr->infos, info);
1419 server_ptr->engine->RemoveSlave(info);
1433 if (server_ptr && server_ptr->engine) {
1435 if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist))
return false;
1436 bool ret = (server_ptr->engine->SwitchMaster(driver_ptr->desc_ptr, paramlist) == 0);
1437 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 bool jackctl_server_load_session_file(jackctl_server *server_ptr, const char *file)
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