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);
  1371     if (!server_ptr || !file || !server_ptr->engine) {
  1375     return (server_ptr->engine->LoadInternalSessionFile(file) >= 0);
  1380     if (server_ptr && server_ptr->engine) {
  1381         if (server_ptr->engine->IsRunning()) {
  1382             jack_error(
"Cannot add a slave in a running server");
  1386             if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist)) 
return false;
  1387             JackDriverInfo* info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, paramlist);
  1388             jackctl_destroy_param_list(paramlist);
  1390                 driver_ptr->infos = jack_slist_append(driver_ptr->infos, info);
  1403     if (server_ptr && server_ptr->engine) {
  1404         if (server_ptr->engine->IsRunning()) {
  1405             jack_error(
"Cannot remove a slave from a running server");
  1408             if (driver_ptr->infos) {
  1411                 driver_ptr->infos = jack_slist_remove(driver_ptr->infos, info);
  1412                 server_ptr->engine->RemoveSlave(info);
  1426     if (server_ptr && server_ptr->engine) {
  1428         if (!jackctl_create_param_list(driver_ptr->parameters, ¶mlist)) 
return false;
  1429         bool ret = (server_ptr->engine->SwitchMaster(driver_ptr->desc_ptr, paramlist) == 0);
  1430         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