25 #include <sys/types.h>    34 #include "JackConstants.h"    35 #include "JackPlatformPlug.h"    37 #include "JackControlAPIAndroid.h"    40 #if defined(JACK_DBUS) && defined(__linux__)    42 #include <dbus/dbus.h>    43 #include "audio_reserve.h"    54 #include <CoreFoundation/CFNotificationCenter.h>    55 #include <CoreFoundation/CoreFoundation.h>    57 static void notify_server_start(
const char* server_name)
    60     CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
    61     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
    62             CFSTR(
"com.grame.jackserver.start"),
    65             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
    69 static void notify_server_stop(
const char* server_name)
    72     CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
    73     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
    74             CFSTR(
"com.grame.jackserver.stop"),
    77             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
    83 static void notify_server_start(
const char* server_name)
    85 static void notify_server_stop(
const char* server_name)
    90 static void copyright(FILE* file)
    92     fprintf(file, 
"jackdmp " VERSION 
"\n"    93             "Copyright 2001-2005 Paul Davis and others.\n"    94             "Copyright 2004-2016 Grame.\n"    95             "Copyright 2016-2017 Filipe Coelho.\n"    96             "jackdmp comes with ABSOLUTELY NO WARRANTY\n"    97             "This is free software, and you are welcome to redistribute it\n"    98             "under certain conditions; see the file COPYING for details\n");
   109         node_ptr = jack_slist_next(node_ptr);
   123         node_ptr = jack_slist_next(node_ptr);
   131     while (parameters_list) {
   135         parameters_list = jack_slist_next(parameters_list);
   142 static void jackctl_server_switch_master_dummy(
jackctl_server_t * server_ctl, 
char * master_driver_name)
   144     static bool is_dummy_driver = 
false;
   145     if(!strcmp(master_driver_name, 
"dummy")) {
   149     if(is_dummy_driver) {
   150         is_dummy_driver = 
false;
   151         driver_ctr = jackctl_server_get_driver(server_ctl, master_driver_name);
   153         is_dummy_driver = 
true;
   154         driver_ctr = jackctl_server_get_driver(server_ctl, 
"dummy");
   164     fprintf(file, 
"Available backends:\n");
   169         node_ptr = jack_slist_next(node_ptr);
   178     fprintf(file, 
"Available internals:\n");
   183         node_ptr = jack_slist_next(node_ptr);
   191     const JSList * server_parameters;
   196             "Usage: jackdmp [ --no-realtime OR -r ]\n"   197             "               [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"   198             "      (the two previous arguments are mutually exclusive. The default is --realtime)\n"   199             "               [ --name OR -n server-name ]\n"   200             "               [ --timeout OR -t client-timeout-in-msecs ]\n"   201             "               [ --loopback OR -L loopback-port-number ]\n"   202             "               [ --port-max OR -p maximum-number-of-ports]\n"   203             "               [ --slave-backend OR -X slave-backend-name ]\n"   204             "               [ --internal-client OR -I internal-client-name ]\n"   205             "               [ --internal-session-file OR -C internal-session-file ]\n"   206             "               [ --verbose OR -v ]\n"   208             "               [ --clocksource OR -c [ h(pet) | s(ystem) ]\n"   210             "               [ --autoconnect OR -a <modechar>]\n");
   213     param = jackctl_get_parameter(server_parameters, 
"self-connect-mode");
   215             "                 where <modechar> is one of:\n");
   220         if (value.c == JACK_DEFAULT_SELF_CONNECT_MODE)
   222             fprintf(file, 
" (default)");
   228             "               [ --replace-registry ]\n"   229             "               [ --silent OR -s ]\n"   230             "               [ --sync OR -S ]\n"   231             "               [ --temporary OR -T ]\n"   232             "               [ --version OR -V ]\n"   233             "         -d master-backend-name [ ... master-backend args ... ]\n"   234             "       jackdmp -d master-backend-name --help\n"   235             "             to display options for each master backend\n\n");
   238         print_server_drivers(server, file);
   239         print_server_internals(server, file);
   244 extern "C" void silent_jack_error_callback(
const char *desc);
   248     printf( 
"jackdmp version " VERSION 
" tmpdir "   249             jack_server_dir 
" protocol %d" "\n",
   250             JACK_PROTOCOL_VERSION);
   255 int main(
int argc, 
char** argv)
   258     const JSList * server_parameters;
   259     const char* server_name = JACK_DEFAULT_SERVER_NAME;
   262     int replace_registry = 0;
   264     for(
int a = 1; a < argc; ++a) {
   265         if( !strcmp(argv[a], 
"--version") || !strcmp(argv[a], 
"-V") ) {
   269     const char *options = 
"-d:X:I:P:uvshrRL:STFl:t:mn:p:C:"   276     struct option long_options[] = {
   278                                        { 
"clock-source", 1, 0, 
'c' },
   280                                        { 
"internal-session-file", 1, 0, 
'C' },
   281                                        { 
"loopback-driver", 1, 0, 
'L' },
   282                                        { 
"audio-driver", 1, 0, 
'd' },
   283                                        { 
"midi-driver", 1, 0, 
'X' },
   284                                        { 
"internal-client", 1, 0, 
'I' },
   285                                        { 
"verbose", 0, 0, 
'v' },
   286                                        { 
"help", 0, 0, 
'h' },
   287                                        { 
"port-max", 1, 0, 
'p' },
   288                                        { 
"no-mlock", 0, 0, 
'm' },
   289                                        { 
"name", 1, 0, 
'n' },
   290                                        { 
"unlock", 0, 0, 
'u' },
   291                                        { 
"realtime", 0, 0, 
'R' },
   292                                        { 
"no-realtime", 0, 0, 
'r' },
   293                                        { 
"replace-registry", 0, &replace_registry, 0 },
   294                                        { 
"loopback", 0, 0, 
'L' },
   295                                        { 
"realtime-priority", 1, 0, 
'P' },
   296                                        { 
"timeout", 1, 0, 
't' },
   297                                        { 
"temporary", 0, 0, 
'T' },
   298                                        { 
"silent", 0, 0, 
's' },
   299                                        { 
"sync", 0, 0, 
'S' },
   300                                        { 
"autoconnect", 1, 0, 
'a' },
   305     int option_index = 0;
   306     char* internal_session_file = NULL;
   307     char* master_driver_name = NULL;
   308     char** master_driver_args = NULL;
   309     int master_driver_nargs = 1;
   315     std::list<char*> internals_list;
   316     std::list<char*> slaves_list;
   317     std::list<char*>::iterator it;
   320     int return_value = -1;
   321     bool notify_sent = 
false;
   324 #if defined(JACK_DBUS) && defined(__linux__)   325     if (getenv(
"JACK_NO_AUDIO_RESERVATION"))
   332     if (server_ctl == NULL) {
   333         fprintf(stderr, 
"Failed to create server object\n");
   340     while (!master_driver_name &&
   341             (opt = getopt_long(argc, argv, options,
   342                                long_options, &option_index)) != EOF) {
   347                 param = jackctl_get_parameter(server_parameters, 
"clock-source");
   349                     if (tolower (optarg[0]) == 
'h') {
   350                         value.ui = JACK_TIMER_HPET;
   352                     } 
else if (tolower (optarg[0]) == 
'c') {
   357                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
   359                     } 
else if (tolower (optarg[0]) == 
's') {
   360                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
   363                         usage(stdout, server_ctl);
   371                 param = jackctl_get_parameter(server_parameters, 
"self-connect-mode");
   373                     bool value_valid = 
false;
   376                         if( value.c == optarg[0] )
   384                         usage(stdout, server_ctl);
   391                 master_driver_name = optarg;
   395                 loopback = atoi(optarg);
   399                 slaves_list.push_back(optarg);
   403                 internals_list.push_back(optarg);
   407                 param = jackctl_get_parameter(server_parameters, 
"port-max");
   409                     value.ui = atoi(optarg);
   421                 param = jackctl_get_parameter(server_parameters, 
"verbose");
   433                 param = jackctl_get_parameter(server_parameters, 
"sync");
   441                 server_name = optarg;
   442                 param = jackctl_get_parameter(server_parameters, 
"name");
   450                 internal_session_file = optarg;
   454                 param = jackctl_get_parameter(server_parameters, 
"realtime-priority");
   456                     value.i = atoi(optarg);
   462                 param = jackctl_get_parameter(server_parameters, 
"realtime");
   470                 param = jackctl_get_parameter(server_parameters, 
"realtime");
   478                 param = jackctl_get_parameter(server_parameters, 
"temporary");
   486                 param = jackctl_get_parameter(server_parameters, 
"client-timeout");
   488                     value.i = atoi(optarg);
   494                 fprintf(stderr, 
"unknown option character %c\n", optopt);
   498                 usage(stdout, server_ctl);
   504     param = jackctl_get_parameter(server_parameters, 
"replace-registry");
   506         value.b = replace_registry;
   510     if (!master_driver_name) {
   511         usage(stderr, server_ctl, 
false);
   516     master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
   517     if (master_driver_ctl == NULL) {
   518         fprintf(stderr, 
"Unknown driver \"%s\"\n", master_driver_name);
   523         fprintf(stderr, 
"Driver \"%s\" is not a master \n", master_driver_name);
   528         master_driver_nargs = 1 + argc - optind;
   530         master_driver_nargs = 1;
   533     if (master_driver_nargs == 0) {
   534         fprintf(stderr, 
"No driver specified ... hmm. JACK won't do"   535                 " anything when run like this.\n");
   539     master_driver_args = (
char **) malloc(
sizeof(
char *) * master_driver_nargs);
   540     master_driver_args[0] = master_driver_name;
   542     for (i = 1; i < master_driver_nargs; i++) {
   543         master_driver_args[
i] = argv[optind++];
   555         fprintf(stderr, 
"Failed to open server\n");
   560     for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
   561         jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
   562         if (slave_driver_ctl == NULL) {
   563             fprintf(stderr, 
"Unknown driver \"%s\"\n", *it);
   567             fprintf(stderr, 
"Driver \"%s\" is not a slave \n", *it);
   571             fprintf(stderr, 
"Driver \"%s\" cannot be loaded\n", *it);
   578         loopback_driver_ctl = jackctl_server_get_driver(server_ctl, 
"loopback");
   580         if (loopback_driver_ctl != NULL) {
   582             param = jackctl_get_parameter(loopback_parameters, 
"channels");
   588                 fprintf(stderr, 
"Driver \"loopback\" cannot be loaded\n");
   592             fprintf(stderr, 
"Driver \"loopback\" not found\n");
   599         fprintf(stderr, 
"Failed to start server\n");
   604     for (it = internals_list.begin(); it != internals_list.end(); it++) {
   605         jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
   606         if (internal_driver_ctl == NULL) {
   607             fprintf(stderr, 
"Unknown internal \"%s\"\n", *it);
   611             fprintf(stderr, 
"Internal client \"%s\" cannot be loaded\n", *it);
   616     if (internal_session_file != NULL) {
   618             fprintf(stderr, 
"Internal session file %s cannot be loaded!\n", internal_session_file);
   623     notify_server_start(server_name);
   631         int signal = jackctl_wait_signals_and_return(sigmask);
   632         if (signal == SIGUSR2) {
   633             jackctl_server_switch_master_dummy(server_ctl, master_driver_name);
   644         fprintf(stderr, 
"Cannot stop server...\n");
   648     if (loopback > 0 && loopback_driver_ctl) {
   652     for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
   653         jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
   654         if (slave_driver_ctl) {
   660     for (it = internals_list.begin(); it != internals_list.end(); it++) {
   661         jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
   662         if (internal_driver_ctl) {
   671         notify_server_stop(server_name);
 SERVER_EXPORT int jackctl_driver_params_parse(jackctl_driver *driver_ptr, int argc, char *argv[])
SERVER_EXPORT jackctl_sigmask_t * jackctl_setup_signals(unsigned int flags)
SERVER_EXPORT bool jackctl_server_open(jackctl_server *server_ptr, jackctl_driver *driver_ptr)
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_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 
void jack_set_error_function(void(*func)(const char *)) JACK_OPTIONAL_WEAK_EXPORT
SERVER_EXPORT const char * jackctl_parameter_get_name(jackctl_parameter *parameter_ptr)
SERVER_EXPORT bool jackctl_server_stop(jackctl_server *server_ptr)
Type for parameter value. 
SERVER_EXPORT const JSList * jackctl_driver_get_parameters(jackctl_driver *driver_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)
SERVER_EXPORT const JSList * jackctl_server_get_drivers_list(jackctl_server *server_ptr)
SERVER_EXPORT bool jackctl_server_start(jackctl_server *server_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)
#define JACK_PARAM_STRING_MAX
Max length of string parameter value, excluding terminating null char. 
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)
SERVER_EXPORT void jackctl_server_destroy(jackctl_server *server_ptr)
SERVER_EXPORT jackctl_driver_type_t jackctl_driver_get_type(jackctl_driver *driver_ptr)
SERVER_EXPORT const JSList * jackctl_server_get_parameters(jackctl_server *server_ptr)
SERVER_EXPORT void jackctl_wait_signals(jackctl_sigmask_t *sigmask)
SERVER_EXPORT bool jackctl_server_load_internal(jackctl_server *server_ptr, jackctl_internal *internal)