Jack2 1.9.10
|
00001 /* 00002 Copyright (C) 2001 Paul Davis 00003 Copyright (C) 2004-2013 Grame 00004 00005 This program is free software; you can redistribute it and/or modify 00006 it under the terms of the GNU General Public License as published by 00007 the Free Software Foundation; either version 2 of the License, or 00008 (at your option) any later version. 00009 00010 This program is distributed in the hope that it will be useful, 00011 but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00013 GNU General Public License for more details. 00014 00015 You should have received a copy of the GNU General Public License 00016 along with this program; if not, write to the Free Software 00017 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 00018 00019 */ 00020 00021 #include <iostream> 00022 #include <assert.h> 00023 #include <cassert> 00024 #include <csignal> 00025 #include <sys/types.h> 00026 #include <getopt.h> 00027 #include <cstring> 00028 #include <cstdio> 00029 #include <list> 00030 00031 #include "types.h" 00032 #include "jack.h" 00033 #include "control.h" 00034 #include "JackConstants.h" 00035 #include "JackPlatformPlug.h" 00036 #ifdef __ANDROID__ 00037 #include "JackControlAPIAndroid.h" 00038 #endif 00039 00040 #if defined(JACK_DBUS) && defined(__linux__) 00041 #include <dbus/dbus.h> 00042 #include "audio_reserve.h" 00043 #endif 00044 00045 /* 00046 This is a simple port of the old jackdmp.cpp file to use the new jack2 control API. Available options for the server 00047 are "hard-coded" in the source. A much better approach would be to use the control API to: 00048 - dynamically retrieve available server parameters and then prepare to parse them 00049 - get available drivers and their possible parameters, then prepare to parse them. 00050 */ 00051 00052 #ifdef __APPLE__ 00053 #include <CoreFoundation/CFNotificationCenter.h> 00054 #include <CoreFoundation/CoreFoundation.h> 00055 00056 static void notify_server_start(const char* server_name) 00057 { 00058 // Send notification to be used in the JackRouter plugin 00059 CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman); 00060 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(), 00061 CFSTR("com.grame.jackserver.start"), 00062 ref, 00063 NULL, 00064 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions); 00065 CFRelease(ref); 00066 } 00067 00068 static void notify_server_stop(const char* server_name) 00069 { 00070 // Send notification to be used in the JackRouter plugin 00071 CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman); 00072 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(), 00073 CFSTR("com.grame.jackserver.stop"), 00074 ref1, 00075 NULL, 00076 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions); 00077 CFRelease(ref1); 00078 } 00079 00080 #else 00081 00082 static void notify_server_start(const char* server_name) 00083 {} 00084 static void notify_server_stop(const char* server_name) 00085 {} 00086 00087 #endif 00088 00089 static void copyright(FILE* file) 00090 { 00091 fprintf(file, "jackdmp " VERSION "\n" 00092 "Copyright 2001-2005 Paul Davis and others.\n" 00093 "Copyright 2004-2014 Grame.\n" 00094 "jackdmp comes with ABSOLUTELY NO WARRANTY\n" 00095 "This is free software, and you are welcome to redistribute it\n" 00096 "under certain conditions; see the file COPYING for details\n"); 00097 } 00098 00099 static jackctl_driver_t * jackctl_server_get_driver(jackctl_server_t *server, const char *driver_name) 00100 { 00101 const JSList * node_ptr = jackctl_server_get_drivers_list(server); 00102 00103 while (node_ptr) { 00104 if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0) { 00105 return (jackctl_driver_t *)node_ptr->data; 00106 } 00107 node_ptr = jack_slist_next(node_ptr); 00108 } 00109 00110 return NULL; 00111 } 00112 00113 static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name) 00114 { 00115 const JSList * node_ptr = jackctl_server_get_internals_list(server); 00116 00117 while (node_ptr) { 00118 if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) { 00119 return (jackctl_internal_t *)node_ptr->data; 00120 } 00121 node_ptr = jack_slist_next(node_ptr); 00122 } 00123 00124 return NULL; 00125 } 00126 00127 static jackctl_parameter_t * jackctl_get_parameter(const JSList * parameters_list, const char * parameter_name) 00128 { 00129 while (parameters_list) { 00130 if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0) { 00131 return (jackctl_parameter_t *)parameters_list->data; 00132 } 00133 parameters_list = jack_slist_next(parameters_list); 00134 } 00135 00136 return NULL; 00137 } 00138 00139 #ifdef __ANDROID__ 00140 static void jackctl_server_switch_master_dummy(jackctl_server_t * server_ctl, char * master_driver_name) 00141 { 00142 static bool is_dummy_driver = false; 00143 if(!strcmp(master_driver_name, "dummy")) { 00144 return; 00145 } 00146 jackctl_driver_t * driver_ctr; 00147 if(is_dummy_driver) { 00148 is_dummy_driver = false; 00149 driver_ctr = jackctl_server_get_driver(server_ctl, master_driver_name); 00150 } else { 00151 is_dummy_driver = true; 00152 driver_ctr = jackctl_server_get_driver(server_ctl, "dummy"); 00153 } 00154 jackctl_server_switch_master(server_ctl, driver_ctr); 00155 } 00156 #endif 00157 00158 static void print_server_drivers(jackctl_server_t *server, FILE* file) 00159 { 00160 const JSList * node_ptr = jackctl_server_get_drivers_list(server); 00161 00162 fprintf(file, "Available backends:\n"); 00163 00164 while (node_ptr) { 00165 jackctl_driver_t* driver = (jackctl_driver_t *)node_ptr->data; 00166 fprintf(file, " %s (%s)\n", jackctl_driver_get_name(driver), (jackctl_driver_get_type(driver) == JackMaster) ? "master" : "slave"); 00167 node_ptr = jack_slist_next(node_ptr); 00168 } 00169 fprintf(file, "\n"); 00170 } 00171 00172 static void print_server_internals(jackctl_server_t *server, FILE* file) 00173 { 00174 const JSList * node_ptr = jackctl_server_get_internals_list(server); 00175 00176 fprintf(file, "Available internals:\n"); 00177 00178 while (node_ptr) { 00179 jackctl_internal_t* internal = (jackctl_internal_t *)node_ptr->data; 00180 fprintf(file, " %s\n", jackctl_internal_get_name(internal)); 00181 node_ptr = jack_slist_next(node_ptr); 00182 } 00183 fprintf(file, "\n"); 00184 } 00185 00186 static void usage(FILE* file, jackctl_server_t *server, bool full = true) 00187 { 00188 jackctl_parameter_t * param; 00189 const JSList * server_parameters; 00190 uint32_t i; 00191 union jackctl_parameter_value value; 00192 00193 fprintf(file, "\n" 00194 "Usage: jackdmp [ --no-realtime OR -r ]\n" 00195 " [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n" 00196 " (the two previous arguments are mutually exclusive. The default is --realtime)\n" 00197 " [ --name OR -n server-name ]\n" 00198 " [ --timeout OR -t client-timeout-in-msecs ]\n" 00199 " [ --loopback OR -L loopback-port-number ]\n" 00200 " [ --port-max OR -p maximum-number-of-ports]\n" 00201 " [ --slave-backend OR -X slave-backend-name ]\n" 00202 " [ --internal-client OR -I internal-client-name ]\n" 00203 " [ --verbose OR -v ]\n" 00204 #ifdef __linux__ 00205 " [ --clocksource OR -c [ h(pet) | s(ystem) ]\n" 00206 #endif 00207 " [ --autoconnect OR -a <modechar>]\n"); 00208 00209 server_parameters = jackctl_server_get_parameters(server); 00210 param = jackctl_get_parameter(server_parameters, "self-connect-mode"); 00211 fprintf(file, 00212 " where <modechar> is one of:\n"); 00213 for (i = 0; i < jackctl_parameter_get_enum_constraints_count(param); i++) 00214 { 00215 value = jackctl_parameter_get_enum_constraint_value(param, i); 00216 fprintf(file, " '%c' - %s", value.c, jackctl_parameter_get_enum_constraint_description(param, i)); 00217 if (value.c == JACK_DEFAULT_SELF_CONNECT_MODE) 00218 { 00219 fprintf(file, " (default)"); 00220 } 00221 fprintf(file, "\n"); 00222 } 00223 00224 fprintf(file, 00225 " [ --replace-registry ]\n" 00226 " [ --silent OR -s ]\n" 00227 " [ --sync OR -S ]\n" 00228 " [ --temporary OR -T ]\n" 00229 " [ --version OR -V ]\n" 00230 " -d master-backend-name [ ... master-backend args ... ]\n" 00231 " jackdmp -d master-backend-name --help\n" 00232 " to display options for each master backend\n\n"); 00233 00234 if (full) { 00235 print_server_drivers(server, file); 00236 print_server_internals(server, file); 00237 } 00238 } 00239 00240 // Prototype to be found in libjackserver 00241 extern "C" void silent_jack_error_callback(const char *desc); 00242 00243 int main(int argc, char** argv) 00244 { 00245 jackctl_server_t * server_ctl; 00246 const JSList * server_parameters; 00247 const char* server_name = JACK_DEFAULT_SERVER_NAME; 00248 jackctl_driver_t * master_driver_ctl; 00249 jackctl_driver_t * loopback_driver_ctl = NULL; 00250 int replace_registry = 0; 00251 const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:" 00252 "a:" 00253 #ifdef __linux__ 00254 "c:" 00255 #endif 00256 ; 00257 00258 struct option long_options[] = { 00259 #ifdef __linux__ 00260 { "clock-source", 1, 0, 'c' }, 00261 #endif 00262 { "loopback-driver", 1, 0, 'L' }, 00263 { "audio-driver", 1, 0, 'd' }, 00264 { "midi-driver", 1, 0, 'X' }, 00265 { "internal-client", 1, 0, 'I' }, 00266 { "verbose", 0, 0, 'v' }, 00267 { "help", 0, 0, 'h' }, 00268 { "port-max", 1, 0, 'p' }, 00269 { "no-mlock", 0, 0, 'm' }, 00270 { "name", 1, 0, 'n' }, 00271 { "unlock", 0, 0, 'u' }, 00272 { "realtime", 0, 0, 'R' }, 00273 { "no-realtime", 0, 0, 'r' }, 00274 { "replace-registry", 0, &replace_registry, 0 }, 00275 { "loopback", 0, 0, 'L' }, 00276 { "realtime-priority", 1, 0, 'P' }, 00277 { "timeout", 1, 0, 't' }, 00278 { "temporary", 0, 0, 'T' }, 00279 { "version", 0, 0, 'V' }, 00280 { "silent", 0, 0, 's' }, 00281 { "sync", 0, 0, 'S' }, 00282 { "autoconnect", 1, 0, 'a' }, 00283 { 0, 0, 0, 0 } 00284 }; 00285 00286 int i,opt = 0; 00287 int option_index = 0; 00288 char* master_driver_name = NULL; 00289 char** master_driver_args = NULL; 00290 int master_driver_nargs = 1; 00291 int loopback = 0; 00292 bool show_version = false; 00293 jackctl_sigmask_t * sigmask; 00294 jackctl_parameter_t* param; 00295 union jackctl_parameter_value value; 00296 00297 std::list<char*> internals_list; 00298 std::list<char*> slaves_list; 00299 std::list<char*>::iterator it; 00300 00301 // Assume that we fail. 00302 int return_value = -1; 00303 bool notify_sent = false; 00304 00305 copyright(stdout); 00306 #if defined(JACK_DBUS) && defined(__linux__) 00307 server_ctl = jackctl_server_create(audio_acquire, audio_release); 00308 #else 00309 server_ctl = jackctl_server_create(NULL, NULL); 00310 #endif 00311 if (server_ctl == NULL) { 00312 fprintf(stderr, "Failed to create server object\n"); 00313 return -1; 00314 } 00315 00316 server_parameters = jackctl_server_get_parameters(server_ctl); 00317 00318 opterr = 0; 00319 while (!master_driver_name && 00320 (opt = getopt_long(argc, argv, options, 00321 long_options, &option_index)) != EOF) { 00322 switch (opt) { 00323 00324 #ifdef __linux__ 00325 case 'c': 00326 param = jackctl_get_parameter(server_parameters, "clock-source"); 00327 if (param != NULL) { 00328 if (tolower (optarg[0]) == 'h') { 00329 value.ui = JACK_TIMER_HPET; 00330 jackctl_parameter_set_value(param, &value); 00331 } else if (tolower (optarg[0]) == 'c') { 00332 /* For backwards compatibility with scripts, allow 00333 * the user to request the cycle clock on the 00334 * command line, but use the system clock instead 00335 */ 00336 value.ui = JACK_TIMER_SYSTEM_CLOCK; 00337 jackctl_parameter_set_value(param, &value); 00338 } else if (tolower (optarg[0]) == 's') { 00339 value.ui = JACK_TIMER_SYSTEM_CLOCK; 00340 jackctl_parameter_set_value(param, &value); 00341 } else { 00342 usage(stdout, server_ctl); 00343 goto destroy_server; 00344 } 00345 } 00346 break; 00347 #endif 00348 00349 case 'a': 00350 param = jackctl_get_parameter(server_parameters, "self-connect-mode"); 00351 if (param != NULL) { 00352 bool value_valid = false; 00353 for (uint32_t k=0; k<jackctl_parameter_get_enum_constraints_count( param ); k++ ) { 00354 value = jackctl_parameter_get_enum_constraint_value( param, k ); 00355 if( value.c == optarg[0] ) 00356 value_valid = true; 00357 } 00358 00359 if( value_valid ) { 00360 value.c = optarg[0]; 00361 jackctl_parameter_set_value(param, &value); 00362 } else { 00363 usage(stdout, server_ctl); 00364 goto destroy_server; 00365 } 00366 } 00367 break; 00368 00369 case 'd': 00370 master_driver_name = optarg; 00371 break; 00372 00373 case 'L': 00374 loopback = atoi(optarg); 00375 break; 00376 00377 case 'X': 00378 slaves_list.push_back(optarg); 00379 break; 00380 00381 case 'I': 00382 internals_list.push_back(optarg); 00383 break; 00384 00385 case 'p': 00386 param = jackctl_get_parameter(server_parameters, "port-max"); 00387 if (param != NULL) { 00388 value.ui = atoi(optarg); 00389 jackctl_parameter_set_value(param, &value); 00390 } 00391 break; 00392 00393 case 'm': 00394 break; 00395 00396 case 'u': 00397 break; 00398 00399 case 'v': 00400 param = jackctl_get_parameter(server_parameters, "verbose"); 00401 if (param != NULL) { 00402 value.b = true; 00403 jackctl_parameter_set_value(param, &value); 00404 } 00405 break; 00406 00407 case 's': 00408 jack_set_error_function(silent_jack_error_callback); 00409 break; 00410 00411 case 'S': 00412 param = jackctl_get_parameter(server_parameters, "sync"); 00413 if (param != NULL) { 00414 value.b = true; 00415 jackctl_parameter_set_value(param, &value); 00416 } 00417 break; 00418 00419 case 'n': 00420 server_name = optarg; 00421 param = jackctl_get_parameter(server_parameters, "name"); 00422 if (param != NULL) { 00423 strncpy(value.str, optarg, JACK_PARAM_STRING_MAX); 00424 jackctl_parameter_set_value(param, &value); 00425 } 00426 break; 00427 00428 case 'P': 00429 param = jackctl_get_parameter(server_parameters, "realtime-priority"); 00430 if (param != NULL) { 00431 value.i = atoi(optarg); 00432 jackctl_parameter_set_value(param, &value); 00433 } 00434 break; 00435 00436 case 'r': 00437 param = jackctl_get_parameter(server_parameters, "realtime"); 00438 if (param != NULL) { 00439 value.b = false; 00440 jackctl_parameter_set_value(param, &value); 00441 } 00442 break; 00443 00444 case 'R': 00445 param = jackctl_get_parameter(server_parameters, "realtime"); 00446 if (param != NULL) { 00447 value.b = true; 00448 jackctl_parameter_set_value(param, &value); 00449 } 00450 break; 00451 00452 case 'T': 00453 param = jackctl_get_parameter(server_parameters, "temporary"); 00454 if (param != NULL) { 00455 value.b = true; 00456 jackctl_parameter_set_value(param, &value); 00457 } 00458 break; 00459 00460 case 't': 00461 param = jackctl_get_parameter(server_parameters, "client-timeout"); 00462 if (param != NULL) { 00463 value.i = atoi(optarg); 00464 jackctl_parameter_set_value(param, &value); 00465 } 00466 break; 00467 00468 case 'V': 00469 show_version = true; 00470 break; 00471 00472 default: 00473 fprintf(stderr, "unknown option character %c\n", optopt); 00474 /*fallthru*/ 00475 00476 case 'h': 00477 usage(stdout, server_ctl); 00478 goto destroy_server; 00479 } 00480 } 00481 00482 // Long option with no letter so treated separately 00483 param = jackctl_get_parameter(server_parameters, "replace-registry"); 00484 if (param != NULL) { 00485 value.b = replace_registry; 00486 jackctl_parameter_set_value(param, &value); 00487 } 00488 00489 if (show_version) { 00490 printf( "jackdmp version " VERSION 00491 " tmpdir " jack_server_dir 00492 " protocol %d" 00493 "\n", JACK_PROTOCOL_VERSION); 00494 return -1; 00495 } 00496 00497 if (!master_driver_name) { 00498 usage(stderr, server_ctl, false); 00499 goto destroy_server; 00500 } 00501 00502 // Master driver 00503 master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name); 00504 if (master_driver_ctl == NULL) { 00505 fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name); 00506 goto destroy_server; 00507 } 00508 00509 if (jackctl_driver_get_type(master_driver_ctl) != JackMaster) { 00510 fprintf(stderr, "Driver \"%s\" is not a master \n", master_driver_name); 00511 goto destroy_server; 00512 } 00513 00514 if (optind < argc) { 00515 master_driver_nargs = 1 + argc - optind; 00516 } else { 00517 master_driver_nargs = 1; 00518 } 00519 00520 if (master_driver_nargs == 0) { 00521 fprintf(stderr, "No driver specified ... hmm. JACK won't do" 00522 " anything when run like this.\n"); 00523 goto destroy_server; 00524 } 00525 00526 master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs); 00527 master_driver_args[0] = master_driver_name; 00528 00529 for (i = 1; i < master_driver_nargs; i++) { 00530 master_driver_args[i] = argv[optind++]; 00531 } 00532 00533 if (jackctl_driver_params_parse(master_driver_ctl, master_driver_nargs, master_driver_args)) { 00534 goto destroy_server; 00535 } 00536 00537 // Setup signals 00538 sigmask = jackctl_setup_signals(0); 00539 00540 // Open server 00541 if (! jackctl_server_open(server_ctl, master_driver_ctl)) { 00542 fprintf(stderr, "Failed to open server\n"); 00543 goto destroy_server; 00544 } 00545 00546 // Slave drivers 00547 for (it = slaves_list.begin(); it != slaves_list.end(); it++) { 00548 jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it); 00549 if (slave_driver_ctl == NULL) { 00550 fprintf(stderr, "Unknown driver \"%s\"\n", *it); 00551 goto close_server; 00552 } 00553 if (jackctl_driver_get_type(slave_driver_ctl) != JackSlave) { 00554 fprintf(stderr, "Driver \"%s\" is not a slave \n", *it); 00555 goto close_server; 00556 } 00557 if (!jackctl_server_add_slave(server_ctl, slave_driver_ctl)) { 00558 fprintf(stderr, "Driver \"%s\" cannot be loaded\n", *it); 00559 goto close_server; 00560 } 00561 } 00562 00563 // Loopback driver 00564 if (loopback > 0) { 00565 loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback"); 00566 00567 if (loopback_driver_ctl != NULL) { 00568 const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl); 00569 param = jackctl_get_parameter(loopback_parameters, "channels"); 00570 if (param != NULL) { 00571 value.ui = loopback; 00572 jackctl_parameter_set_value(param, &value); 00573 } 00574 if (!jackctl_server_add_slave(server_ctl, loopback_driver_ctl)) { 00575 fprintf(stderr, "Driver \"loopback\" cannot be loaded\n"); 00576 goto close_server; 00577 } 00578 } else { 00579 fprintf(stderr, "Driver \"loopback\" not found\n"); 00580 goto close_server; 00581 } 00582 } 00583 00584 // Start the server 00585 if (!jackctl_server_start(server_ctl)) { 00586 fprintf(stderr, "Failed to start server\n"); 00587 goto close_server; 00588 } 00589 00590 // Internal clients 00591 for (it = internals_list.begin(); it != internals_list.end(); it++) { 00592 jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it); 00593 if (internal_driver_ctl == NULL) { 00594 fprintf(stderr, "Unknown internal \"%s\"\n", *it); 00595 goto stop_server; 00596 } 00597 if (!jackctl_server_load_internal(server_ctl, internal_driver_ctl)) { 00598 fprintf(stderr, "Internal client \"%s\" cannot be loaded\n", *it); 00599 goto stop_server; 00600 } 00601 } 00602 00603 notify_server_start(server_name); 00604 notify_sent = true; 00605 return_value = 0; 00606 00607 // Waits for signal 00608 #ifdef __ANDROID__ 00609 //reserve SIGUSR2 signal for switching master driver 00610 while(1) { 00611 int signal = jackctl_wait_signals_and_return(sigmask); 00612 if (signal == SIGUSR2) { 00613 jackctl_server_switch_master_dummy(server_ctl, master_driver_name); 00614 } else { 00615 break; 00616 } 00617 } 00618 #else 00619 jackctl_wait_signals(sigmask); 00620 #endif 00621 00622 stop_server: 00623 if (!jackctl_server_stop(server_ctl)) { 00624 fprintf(stderr, "Cannot stop server...\n"); 00625 } 00626 00627 close_server: 00628 if (loopback > 0 && loopback_driver_ctl) { 00629 jackctl_server_remove_slave(server_ctl, loopback_driver_ctl); 00630 } 00631 // Slave drivers 00632 for (it = slaves_list.begin(); it != slaves_list.end(); it++) { 00633 jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it); 00634 if (slave_driver_ctl) { 00635 jackctl_server_remove_slave(server_ctl, slave_driver_ctl); 00636 } 00637 } 00638 00639 // Internal clients 00640 for (it = internals_list.begin(); it != internals_list.end(); it++) { 00641 jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it); 00642 if (internal_driver_ctl) { 00643 jackctl_server_unload_internal(server_ctl, internal_driver_ctl); 00644 } 00645 } 00646 jackctl_server_close(server_ctl); 00647 00648 destroy_server: 00649 jackctl_server_destroy(server_ctl); 00650 if (notify_sent) { 00651 notify_server_stop(server_name); 00652 } 00653 return return_value; 00654 }