int main(int argc, char** argv)
{
jackctl_server_t * server_ctl;
const JSList * server_parameters;
const char* server_name = "default";
jackctl_driver_t * master_driver_ctl;
jackctl_driver_t * loopback_driver_ctl = NULL;
int replace_registry = 0;
const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
"a:"
#ifdef __linux__
"c:"
#endif
;
struct option long_options[] = {
#ifdef __linux__
{ "clock-source", 1, 0, 'c' },
#endif
{ "loopback-driver", 1, 0, 'L' },
{ "audio-driver", 1, 0, 'd' },
{ "midi-driver", 1, 0, 'X' },
{ "internal-client", 1, 0, 'I' },
{ "verbose", 0, 0, 'v' },
{ "help", 0, 0, 'h' },
{ "port-max", 1, 0, 'p' },
{ "no-mlock", 0, 0, 'm' },
{ "name", 1, 0, 'n' },
{ "unlock", 0, 0, 'u' },
{ "realtime", 0, 0, 'R' },
{ "no-realtime", 0, 0, 'r' },
{ "replace-registry", 0, &replace_registry, 0 },
{ "loopback", 0, 0, 'L' },
{ "realtime-priority", 1, 0, 'P' },
{ "timeout", 1, 0, 't' },
{ "temporary", 0, 0, 'T' },
{ "version", 0, 0, 'V' },
{ "silent", 0, 0, 's' },
{ "sync", 0, 0, 'S' },
{ "autoconnect", 1, 0, 'a' },
{ 0, 0, 0, 0 }
};
int i,opt = 0;
int option_index = 0;
char* master_driver_name = NULL;
char** master_driver_args = NULL;
int master_driver_nargs = 1;
int loopback = 0;
bool show_version = false;
jackctl_sigmask_t * sigmask;
jackctl_parameter_t* param;
union jackctl_parameter_value value;
std::list<char*> internals_list;
std::list<char*> slaves_list;
std::list<char*>::iterator it;
// Assume that we fail.
int return_value = -1;
bool notify_sent = false;
copyright(stdout);
#if defined(JACK_DBUS) && defined(__linux__)
server_ctl = jackctl_server_create(audio_acquire, audio_release);
#else
server_ctl = jackctl_server_create(NULL, NULL);
#endif
if (server_ctl == NULL) {
fprintf(stderr, "Failed to create server object\n");
return -1;
}
server_parameters = jackctl_server_get_parameters(server_ctl);
opterr = 0;
while (!master_driver_name &&
(opt = getopt_long(argc, argv, options,
long_options, &option_index)) != EOF) {
switch (opt) {
#ifdef __linux__
case 'c':
param = jackctl_get_parameter(server_parameters, "clock-source");
if (param != NULL) {
if (tolower (optarg[0]) == 'h') {
value.ui = JACK_TIMER_HPET;
jackctl_parameter_set_value(param, &value);
} else if (tolower (optarg[0]) == 'c') {
value.ui = JACK_TIMER_CYCLE_COUNTER;
jackctl_parameter_set_value(param, &value);
} else if (tolower (optarg[0]) == 's') {
value.ui = JACK_TIMER_SYSTEM_CLOCK;
jackctl_parameter_set_value(param, &value);
} else {
usage(stdout, NULL);
goto destroy_server;
}
}
break;
#endif
case 'a':
param = jackctl_get_parameter(server_parameters, "self-connect-mode");
if (param != NULL) {
bool value_valid = false;
for (uint32_t k=0; k<jackctl_parameter_get_enum_constraints_count( param ); k++ ) {
value = jackctl_parameter_get_enum_constraint_value( param, k );
if( value.c == optarg[0] )
value_valid = true;
}
if( value_valid ) {
value.c = optarg[0];
jackctl_parameter_set_value(param, &value);
} else {
usage(stdout, NULL);
goto destroy_server;
}
}
break;
case 'd':
master_driver_name = optarg;
break;
case 'L':
loopback = atoi(optarg);
break;
case 'X':
slaves_list.push_back(optarg);
break;
case 'I':
internals_list.push_back(optarg);
break;
case 'p':
param = jackctl_get_parameter(server_parameters, "port-max");
if (param != NULL) {
value.ui = atoi(optarg);
jackctl_parameter_set_value(param, &value);
}
break;
case 'v':
param = jackctl_get_parameter(server_parameters, "verbose");
if (param != NULL) {
value.b = true;
jackctl_parameter_set_value(param, &value);
}
break;
case 's':
jack_set_error_function(silent_jack_error_callback);
break;
case 'S':
param = jackctl_get_parameter(server_parameters, "sync");
if (param != NULL) {
value.b = true;
jackctl_parameter_set_value(param, &value);
}
break;
case 'n':
server_name = optarg;
param = jackctl_get_parameter(server_parameters, "name");
if (param != NULL) {
strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
jackctl_parameter_set_value(param, &value);
}
break;
case 'P':
param = jackctl_get_parameter(server_parameters, "realtime-priority");
if (param != NULL) {
value.i = atoi(optarg);
jackctl_parameter_set_value(param, &value);
}
break;
case 'r':
param = jackctl_get_parameter(server_parameters, "realtime");
if (param != NULL) {
value.b = false;
jackctl_parameter_set_value(param, &value);
}
break;
case 'R':
param = jackctl_get_parameter(server_parameters, "realtime");
if (param != NULL) {
value.b = true;
jackctl_parameter_set_value(param, &value);
}
break;
case 'T':
param = jackctl_get_parameter(server_parameters, "temporary");
if (param != NULL) {
value.b = true;
jackctl_parameter_set_value(param, &value);
}
break;
case 't':
param = jackctl_get_parameter(server_parameters, "client-timeout");
if (param != NULL) {
value.i = atoi(optarg);
jackctl_parameter_set_value(param, &value);
}
break;
case 'V':
show_version = true;
break;
default:
fprintf(stderr, "unknown option character %c\n", optopt);
/*fallthru*/
case 'h':
usage(stdout, server_ctl);
goto destroy_server;
}
}
// Long option with no letter so treated separately
param = jackctl_get_parameter(server_parameters, "replace-registry");
if (param != NULL) {
value.b = replace_registry;
jackctl_parameter_set_value(param, &value);
}
if (show_version) {
printf( "jackdmp version " VERSION
" tmpdir " jack_server_dir
" protocol %d"
"\n", JACK_PROTOCOL_VERSION);
return -1;
}
if (!master_driver_name) {
usage(stderr, NULL);
goto destroy_server;
}
// Master driver
master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
if (master_driver_ctl == NULL) {
fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name);
goto destroy_server;
}
if (jackctl_driver_get_type(master_driver_ctl) != JackMaster) {
fprintf(stderr, "Driver \"%s\" is not a master \n", master_driver_name);
goto destroy_server;
}
if (optind < argc) {
master_driver_nargs = 1 + argc - optind;
} else {
master_driver_nargs = 1;
}
if (master_driver_nargs == 0) {
fprintf(stderr, "No driver specified ... hmm. JACK won't do"
" anything when run like this.\n");
goto destroy_server;
}
master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs);
master_driver_args[0] = master_driver_name;
for (i = 1; i < master_driver_nargs; i++) {
master_driver_args[i] = argv[optind++];
}
if (jackctl_driver_params_parse(master_driver_ctl, master_driver_nargs, master_driver_args)) {
goto destroy_server;
}
// Setup signals
sigmask = jackctl_setup_signals(0);
// Open server
if (! jackctl_server_open(server_ctl, master_driver_ctl)) {
fprintf(stderr, "Failed to open server\n");
goto destroy_server;
}
// Slave drivers
for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
if (slave_driver_ctl == NULL) {
fprintf(stderr, "Unknown driver \"%s\"\n", *it);
goto close_server;
}
if (jackctl_driver_get_type(slave_driver_ctl) != JackSlave) {
fprintf(stderr, "Driver \"%s\" is not a slave \n", *it);
goto close_server;
}
if (!jackctl_server_add_slave(server_ctl, slave_driver_ctl)) {
fprintf(stderr, "Driver \"%s\" cannot be loaded\n", *it);
goto close_server;
}
}
// Loopback driver
if (loopback > 0) {
loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
if (loopback_driver_ctl != NULL) {
const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
param = jackctl_get_parameter(loopback_parameters, "channels");
if (param != NULL) {
value.ui = loopback;
jackctl_parameter_set_value(param, &value);
}
if (!jackctl_server_add_slave(server_ctl, loopback_driver_ctl)) {
fprintf(stderr, "Driver \"loopback\" cannot be loaded\n");
goto close_server;
}
} else {
fprintf(stderr, "Driver \"loopback\" not found\n");
goto close_server;
}
}
// Start the server
if (!jackctl_server_start(server_ctl)) {
fprintf(stderr, "Failed to start server\n");
goto close_server;
}
// Internal clients
for (it = internals_list.begin(); it != internals_list.end(); it++) {
jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
if (internal_driver_ctl == NULL) {
fprintf(stderr, "Unknown internal \"%s\"\n", *it);
goto stop_server;
}
if (!jackctl_server_load_internal(server_ctl, internal_driver_ctl)) {
fprintf(stderr, "Internal client \"%s\" cannot be loaded\n", *it);
goto stop_server;
}
}
notify_server_start(server_name);
notify_sent = true;
return_value = 0;
// Waits for signal
jackctl_wait_signals(sigmask);
stop_server:
if (!jackctl_server_stop(server_ctl)) {
fprintf(stderr, "Cannot stop server...\n");
}
close_server:
if (loopback > 0 && loopback_driver_ctl) {
jackctl_server_remove_slave(server_ctl, loopback_driver_ctl);
}
// Slave drivers
for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
if (slave_driver_ctl) {
jackctl_server_remove_slave(server_ctl, slave_driver_ctl);
}
}
// Internal clients
for (it = internals_list.begin(); it != internals_list.end(); it++) {
jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
if (internal_driver_ctl) {
jackctl_server_unload_internal(server_ctl, internal_driver_ctl);
}
}
jackctl_server_close(server_ctl);
destroy_server:
jackctl_server_destroy(server_ctl);
if (notify_sent) {
notify_server_stop(server_name);
}
return return_value;
}
int main(int argc, char *argv[])
{
jackctl_server_t * server;
const JSList * parameters;
const JSList * drivers;
const JSList * internals;
const JSList * node_ptr;
jackctl_sigmask_t * sigmask;
int opt, option_index;
const char* driver_name = "dummy";
const char* client_name = "audioadapter";
const char *options = "d:c:";
struct option long_options[] = {
{"driver", 1, 0, 'd'},
{"client", 1, 0, 'c'},
};
while ((opt = getopt_long (argc, argv, options, long_options, &option_index)) != EOF) {
switch (opt) {
case 'd':
driver_name = optarg;
break;
case 'c':
client_name = optarg;
break;
default:
usage();
exit(0);
}
}
server = jackctl_server_create(NULL, NULL);
parameters = jackctl_server_get_parameters(server);
/*
jackctl_parameter_t* param;
union jackctl_parameter_value value;
param = jackctl_get_parameter(parameters, "verbose");
if (param != NULL) {
value.b = true;
jackctl_parameter_set_value(param, &value);
}
*/
printf("\n========================== \n");
printf("List of server parameters \n");
printf("========================== \n");
print_parameters(parameters);
printf("\n========================== \n");
printf("List of drivers \n");
printf("========================== \n");
drivers = jackctl_server_get_drivers_list(server);
node_ptr = drivers;
while (node_ptr != NULL) {
print_driver((jackctl_driver_t *)node_ptr->data);
node_ptr = jack_slist_next(node_ptr);
}
printf("\n========================== \n");
printf("List of internal clients \n");
printf("========================== \n");
internals = jackctl_server_get_internals_list(server);
node_ptr = internals;
while (node_ptr != NULL) {
print_internal((jackctl_internal_t *)node_ptr->data);
node_ptr = jack_slist_next(node_ptr);
}
// No error checking in this simple example...
jackctl_server_open(server, jackctl_server_get_driver(server, driver_name));
jackctl_server_start(server);
jackctl_server_load_internal(server, jackctl_server_get_internal(server, client_name));
/*
// Switch master test
jackctl_driver_t* master;
usleep(5000000);
printf("jackctl_server_load_master\n");
master = jackctl_server_get_driver(server, "coreaudio");
jackctl_server_switch_master(server, master);
usleep(5000000);
printf("jackctl_server_load_master\n");
master = jackctl_server_get_driver(server, "dummy");
jackctl_server_switch_master(server, master);
*/
sigmask = jackctl_setup_signals(0);
jackctl_wait_signals(sigmask);
jackctl_server_stop(server);
jackctl_server_close(server);
jackctl_server_destroy(server);
return 0;
}
// bool jackctl_server_start(jackctl_server_t * server);
static int _start(ClientData clientData, Tcl_Interp *interp, int argc, Tcl_Obj* const *objv) {
if (argc != 3) return fw_error_str(interp, "usage: jack-ctl start server");
jackctl_server_t * server;
if (_get_pointer(interp, objv[2], (void**)&server) != TCL_OK) return TCL_ERROR;
return _return_bool(interp, jackctl_server_start(server));
}