00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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 "JackConstants.h"
00034 #include "JackDriverLoader.h"
00035
00036 #if defined(JACK_DBUS) && defined(__linux__)
00037 #include <dbus/dbus.h>
00038 #include "audio_reserve.h"
00039 #endif
00040
00041
00042
00043
00044
00045
00046
00047
00048 #ifdef __APPLE__
00049 #include <CoreFoundation/CFNotificationCenter.h>
00050 #include <CoreFoundation/CoreFoundation.h>
00051
00052 static void notify_server_start(const char* server_name)
00053 {
00054
00055 CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
00056 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
00057 CFSTR("com.grame.jackserver.start"),
00058 ref,
00059 NULL,
00060 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
00061 CFRelease(ref);
00062 }
00063
00064 static void notify_server_stop(const char* server_name)
00065 {
00066
00067 CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
00068 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
00069 CFSTR("com.grame.jackserver.stop"),
00070 ref1,
00071 NULL,
00072 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
00073 CFRelease(ref1);
00074 }
00075
00076 #else
00077
00078 static void notify_server_start(const char* server_name)
00079 {}
00080 static void notify_server_stop(const char* server_name)
00081 {}
00082
00083 #endif
00084
00085 static void copyright(FILE* file)
00086 {
00087 fprintf(file, "jackdmp " VERSION "\n"
00088 "Copyright 2001-2005 Paul Davis and others.\n"
00089 "Copyright 2004-2011 Grame.\n"
00090 "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
00091 "This is free software, and you are welcome to redistribute it\n"
00092 "under certain conditions; see the file COPYING for details\n");
00093 }
00094
00095 static void usage(FILE* file)
00096 {
00097 fprintf(file, "\n"
00098 "usage: jackdmp [ --no-realtime OR -r ]\n"
00099 " [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
00100 " (the two previous arguments are mutually exclusive. The default is --realtime)\n"
00101 " [ --name OR -n server-name ]\n"
00102 " [ --timeout OR -t client-timeout-in-msecs ]\n"
00103 " [ --loopback OR -L loopback-port-number ]\n"
00104 " [ --port-max OR -p maximum-number-of-ports]\n"
00105 " [ --slave-backend OR -X slave-backend-name ]\n"
00106 " [ --internal-client OR -I internal-client-name ]\n"
00107 " [ --verbose OR -v ]\n"
00108 #ifdef __linux__
00109 " [ --clocksource OR -c [ c(ycle) | h(pet) | s(ystem) ]\n"
00110 #endif
00111 " [ --replace-registry ]\n"
00112 " [ --silent OR -s ]\n"
00113 " [ --sync OR -S ]\n"
00114 " [ --temporary OR -T ]\n"
00115 " [ --version OR -V ]\n"
00116 " -d master-backend-name [ ... master-backend args ... ]\n"
00117 #ifdef __APPLE__
00118 " Available master backends may include: coreaudio, dummy or net.\n\n"
00119 #endif
00120 #ifdef WIN32
00121 " Available master backends may include: portaudio, dummy or net.\n\n"
00122 #endif
00123 #ifdef __linux__
00124 " Available master backends may include: alsa, dummy, freebob, firewire or net\n\n"
00125 #endif
00126 #if defined(__sun__) || defined(sun)
00127 " Available master backends may include: boomer, oss, dummy or net.\n\n"
00128 #endif
00129 " jackdmp -d master-backend-name --help\n"
00130 " to display options for each master backend\n\n");
00131 }
00132
00133
00134 static jackctl_driver_t *
00135 jackctl_server_get_driver(
00136 jackctl_server_t *server,
00137 const char *driver_name)
00138 {
00139 const JSList * node_ptr;
00140
00141 node_ptr = jackctl_server_get_drivers_list(server);
00142
00143 while (node_ptr)
00144 {
00145 if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
00146 {
00147 return (jackctl_driver_t *)node_ptr->data;
00148 }
00149
00150 node_ptr = jack_slist_next(node_ptr);
00151 }
00152
00153 return NULL;
00154 }
00155
00156 static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
00157 {
00158 const JSList * node_ptr = jackctl_server_get_internals_list(server);
00159
00160 while (node_ptr) {
00161 if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
00162 return (jackctl_internal_t *)node_ptr->data;
00163 }
00164 node_ptr = jack_slist_next(node_ptr);
00165 }
00166
00167 return NULL;
00168 }
00169
00170 static jackctl_parameter_t *
00171 jackctl_get_parameter(
00172 const JSList * parameters_list,
00173 const char * parameter_name)
00174 {
00175 while (parameters_list)
00176 {
00177 if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
00178 {
00179 return (jackctl_parameter_t *)parameters_list->data;
00180 }
00181
00182 parameters_list = jack_slist_next(parameters_list);
00183 }
00184
00185 return NULL;
00186 }
00187
00188 int main(int argc, char* argv[])
00189 {
00190 jackctl_server_t * server_ctl;
00191 const JSList * server_parameters;
00192 const char* server_name = "default";
00193 jackctl_driver_t * master_driver_ctl;
00194 jackctl_driver_t * loopback_driver_ctl;
00195 int replace_registry = 0;
00196
00197 const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
00198 #ifdef __linux__
00199 "c:"
00200 #endif
00201 ;
00202
00203 struct option long_options[] = {
00204 #ifdef __linux__
00205 { "clock-source", 1, 0, 'c' },
00206 #endif
00207 { "loopback-driver", 1, 0, 'L' },
00208 { "audio-driver", 1, 0, 'd' },
00209 { "midi-driver", 1, 0, 'X' },
00210 { "internal-client", 1, 0, 'I' },
00211 { "verbose", 0, 0, 'v' },
00212 { "help", 0, 0, 'h' },
00213 { "port-max", 1, 0, 'p' },
00214 { "no-mlock", 0, 0, 'm' },
00215 { "name", 1, 0, 'n' },
00216 { "unlock", 0, 0, 'u' },
00217 { "realtime", 0, 0, 'R' },
00218 { "no-realtime", 0, 0, 'r' },
00219 { "replace-registry", 0, &replace_registry, 0 },
00220 { "loopback", 0, 0, 'L' },
00221 { "realtime-priority", 1, 0, 'P' },
00222 { "timeout", 1, 0, 't' },
00223 { "temporary", 0, 0, 'T' },
00224 { "version", 0, 0, 'V' },
00225 { "silent", 0, 0, 's' },
00226 { "sync", 0, 0, 'S' },
00227 { 0, 0, 0, 0 }
00228 };
00229
00230 int i,opt = 0;
00231 int option_index = 0;
00232 char* master_driver_name = NULL;
00233 char** master_driver_args = NULL;
00234 int master_driver_nargs = 1;
00235 int do_mlock = 1;
00236 int do_unlock = 0;
00237 int loopback = 0;
00238 bool show_version = false;
00239 sigset_t signals;
00240 jackctl_parameter_t* param;
00241 union jackctl_parameter_value value;
00242
00243 std::list<char*> internals_list;
00244 std::list<char*> slaves_list;
00245 std::list<char*>::iterator it;
00246
00247
00248 int return_value = -1;
00249 bool notify_sent = false;
00250
00251 copyright(stdout);
00252 #if defined(JACK_DBUS) && defined(__linux__)
00253 server_ctl = jackctl_server_create(audio_acquire, audio_release);
00254 #else
00255 server_ctl = jackctl_server_create(NULL, NULL);
00256 #endif
00257 if (server_ctl == NULL) {
00258 fprintf(stderr, "Failed to create server object\n");
00259 return -1;
00260 }
00261
00262 server_parameters = jackctl_server_get_parameters(server_ctl);
00263
00264
00265 param = jackctl_get_parameter(server_parameters, "realtime");
00266 if (param != NULL) {
00267 value.b = true;
00268 jackctl_parameter_set_value(param, &value);
00269 }
00270
00271 opterr = 0;
00272 while (!master_driver_name &&
00273 (opt = getopt_long(argc, argv, options,
00274 long_options, &option_index)) != EOF) {
00275 switch (opt) {
00276
00277 #ifdef __linux__
00278 case 'c':
00279 param = jackctl_get_parameter(server_parameters, "clock-source");
00280 if (param != NULL) {
00281 if (tolower (optarg[0]) == 'h') {
00282 value.ui = JACK_TIMER_HPET;
00283 jackctl_parameter_set_value(param, &value);
00284 } else if (tolower (optarg[0]) == 'c') {
00285 value.ui = JACK_TIMER_CYCLE_COUNTER;
00286 jackctl_parameter_set_value(param, &value);
00287 } else if (tolower (optarg[0]) == 's') {
00288 value.ui = JACK_TIMER_SYSTEM_CLOCK;
00289 jackctl_parameter_set_value(param, &value);
00290 } else {
00291 usage(stdout);
00292 goto destroy_server;
00293 }
00294 }
00295 break;
00296 #endif
00297
00298 case 'd':
00299 master_driver_name = optarg;
00300 break;
00301
00302 case 'L':
00303 loopback = atoi(optarg);
00304 break;
00305
00306 case 'X':
00307 slaves_list.push_back(optarg);
00308 break;
00309
00310 case 'I':
00311 internals_list.push_back(optarg);
00312 break;
00313
00314 case 'p':
00315 param = jackctl_get_parameter(server_parameters, "port-max");
00316 if (param != NULL) {
00317 value.ui = atoi(optarg);
00318 jackctl_parameter_set_value(param, &value);
00319 }
00320 break;
00321
00322 case 'm':
00323 do_mlock = 0;
00324 break;
00325
00326 case 'u':
00327 do_unlock = 1;
00328 break;
00329
00330 case 'v':
00331 param = jackctl_get_parameter(server_parameters, "verbose");
00332 if (param != NULL) {
00333 value.b = true;
00334 jackctl_parameter_set_value(param, &value);
00335 }
00336 break;
00337
00338 case 's':
00339 jack_set_error_function(silent_jack_error_callback);
00340 break;
00341
00342 case 'S':
00343 param = jackctl_get_parameter(server_parameters, "sync");
00344 if (param != NULL) {
00345 value.b = true;
00346 jackctl_parameter_set_value(param, &value);
00347 }
00348 break;
00349
00350 case 'n':
00351 server_name = optarg;
00352 param = jackctl_get_parameter(server_parameters, "name");
00353 if (param != NULL) {
00354 strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
00355 jackctl_parameter_set_value(param, &value);
00356 }
00357 break;
00358
00359 case 'P':
00360 param = jackctl_get_parameter(server_parameters, "realtime-priority");
00361 if (param != NULL) {
00362 value.i = atoi(optarg);
00363 jackctl_parameter_set_value(param, &value);
00364 }
00365 break;
00366
00367 case 'r':
00368 param = jackctl_get_parameter(server_parameters, "realtime");
00369 if (param != NULL) {
00370 value.b = false;
00371 jackctl_parameter_set_value(param, &value);
00372 }
00373 break;
00374
00375 case 'R':
00376 param = jackctl_get_parameter(server_parameters, "realtime");
00377 if (param != NULL) {
00378 value.b = true;
00379 jackctl_parameter_set_value(param, &value);
00380 }
00381 break;
00382
00383 case 'T':
00384 param = jackctl_get_parameter(server_parameters, "temporary");
00385 if (param != NULL) {
00386 value.b = true;
00387 jackctl_parameter_set_value(param, &value);
00388 }
00389 break;
00390
00391 case 't':
00392 param = jackctl_get_parameter(server_parameters, "client-timeout");
00393 if (param != NULL) {
00394 value.i = atoi(optarg);
00395 jackctl_parameter_set_value(param, &value);
00396 }
00397 break;
00398
00399 case 'V':
00400 show_version = true;
00401 break;
00402
00403 default:
00404 fprintf(stderr, "unknown option character %c\n", optopt);
00405
00406
00407 case 'h':
00408 usage(stdout);
00409 goto destroy_server;
00410 }
00411 }
00412
00413
00414 param = jackctl_get_parameter(server_parameters, "replace-registry");
00415 if (param != NULL) {
00416 value.b = replace_registry;
00417 jackctl_parameter_set_value(param, &value);
00418 }
00419
00420 if (show_version) {
00421 printf( "jackdmp version " VERSION
00422 " tmpdir " jack_server_dir
00423 " protocol %d"
00424 "\n", JACK_PROTOCOL_VERSION);
00425 return -1;
00426 }
00427
00428 if (!master_driver_name) {
00429 usage(stderr);
00430 goto destroy_server;
00431 }
00432
00433
00434 master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
00435 if (master_driver_ctl == NULL) {
00436 fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name);
00437 goto destroy_server;
00438 }
00439
00440 if (optind < argc) {
00441 master_driver_nargs = 1 + argc - optind;
00442 } else {
00443 master_driver_nargs = 1;
00444 }
00445
00446 if (master_driver_nargs == 0) {
00447 fprintf(stderr, "No driver specified ... hmm. JACK won't do"
00448 " anything when run like this.\n");
00449 goto destroy_server;
00450 }
00451
00452 master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs);
00453 master_driver_args[0] = master_driver_name;
00454
00455 for (i = 1; i < master_driver_nargs; i++) {
00456 master_driver_args[i] = argv[optind++];
00457 }
00458
00459 if (jackctl_parse_driver_params(master_driver_ctl, master_driver_nargs, master_driver_args)) {
00460 goto destroy_server;
00461 }
00462
00463
00464 signals = jackctl_setup_signals(0);
00465
00466
00467 if (! jackctl_server_open(server_ctl, master_driver_ctl)) {
00468 fprintf(stderr, "Failed to open server\n");
00469 goto destroy_server;
00470 }
00471
00472
00473 for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
00474 jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
00475 if (slave_driver_ctl == NULL) {
00476 fprintf(stderr, "Unknown driver \"%s\"\n", *it);
00477 goto close_server;
00478 }
00479 jackctl_server_add_slave(server_ctl, slave_driver_ctl);
00480 }
00481
00482
00483 if (loopback > 0) {
00484 loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
00485
00486
00487 if (loopback_driver_ctl != NULL) {
00488 const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
00489 param = jackctl_get_parameter(loopback_parameters, "channels");
00490 if (param != NULL) {
00491 value.ui = loopback;
00492 jackctl_parameter_set_value(param, &value);
00493 }
00494 jackctl_server_add_slave(server_ctl, loopback_driver_ctl);
00495 }
00496
00497 }
00498
00499
00500 if (!jackctl_server_start(server_ctl)) {
00501 fprintf(stderr, "Failed to start server\n");
00502 goto close_server;
00503 }
00504
00505
00506 for (it = internals_list.begin(); it != internals_list.end(); it++) {
00507 jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
00508 if (internal_driver_ctl == NULL) {
00509 fprintf(stderr, "Unknown internal \"%s\"\n", *it);
00510 goto stop_server;
00511 }
00512 jackctl_server_load_internal(server_ctl, internal_driver_ctl);
00513 }
00514
00515 notify_server_start(server_name);
00516 notify_sent = true;
00517 return_value = 0;
00518
00519
00520 jackctl_wait_signals(signals);
00521
00522 stop_server:
00523 if (! jackctl_server_stop(server_ctl)) {
00524 fprintf(stderr, "Cannot stop server...\n");
00525 }
00526 if (notify_sent) {
00527 notify_server_stop(server_name);
00528 }
00529 close_server:
00530 jackctl_server_close(server_ctl);
00531 destroy_server:
00532 jackctl_server_destroy(server_ctl);
00533 return return_value;
00534 }