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
00030 #include "types.h"
00031 #include "jack.h"
00032 #include "JackConstants.h"
00033 #include "JackDriverLoader.h"
00034
00035
00036
00037
00038
00039
00040
00041
00042 #ifdef __APPLE__
00043 #include <CoreFoundation/CFNotificationCenter.h>
00044 #include <CoreFoundation/CoreFoundation.h>
00045
00046 static void notify_server_start(const char* server_name)
00047 {
00048
00049 CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
00050 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
00051 CFSTR("com.grame.jackserver.start"),
00052 ref,
00053 NULL,
00054 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
00055 CFRelease(ref);
00056 }
00057
00058 static void notify_server_stop(const char* server_name)
00059 {
00060
00061 CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
00062 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
00063 CFSTR("com.grame.jackserver.stop"),
00064 ref1,
00065 NULL,
00066 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
00067 CFRelease(ref1);
00068 }
00069
00070 #else
00071
00072 static void notify_server_start(const char* server_name)
00073 {}
00074 static void notify_server_stop(const char* server_name)
00075 {}
00076
00077 #endif
00078
00079 static void silent_jack_error_callback(const char *desc)
00080 {}
00081
00082 static void copyright(FILE* file)
00083 {
00084 fprintf(file, "jackdmp " VERSION "\n"
00085 "Copyright 2001-2005 Paul Davis and others.\n"
00086 "Copyright 2004-2008 Grame.\n"
00087 "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
00088 "This is free software, and you are welcome to redistribute it\n"
00089 "under certain conditions; see the file COPYING for details\n");
00090 }
00091
00092 static void usage(FILE* file)
00093 {
00094 fprintf(file, "\n"
00095 "usage: jackdmp [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
00096 " [ --name OR -n server-name ]\n"
00097 " [ --timeout OR -t client-timeout-in-msecs ]\n"
00098 " [ --loopback OR -L loopback-port-number ]\n"
00099 " [ --verbose OR -v ]\n"
00100 " [ --replace-registry OR -r ]\n"
00101 " [ --silent OR -s ]\n"
00102 " [ --sync OR -S ]\n"
00103 " [ --temporary OR -T ]\n"
00104 " [ --version OR -V ]\n"
00105 " -d driver [ ... driver args ... ]\n"
00106 " where driver can be `alsa', `coreaudio', 'portaudio' or `dummy'\n"
00107 " jackdmp -d driver --help\n"
00108 " to display options for each driver\n\n");
00109 }
00110
00111
00112 static jackctl_driver_t *
00113 jackctl_server_get_driver(
00114 jackctl_server_t *server,
00115 const char *driver_name)
00116 {
00117 const JSList * node_ptr;
00118
00119 node_ptr = jackctl_server_get_drivers_list(server);
00120
00121 while (node_ptr)
00122 {
00123 if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
00124 {
00125 return (jackctl_driver_t *)node_ptr->data;
00126 }
00127
00128 node_ptr = jack_slist_next(node_ptr);
00129 }
00130
00131 return NULL;
00132 }
00133
00134 static jackctl_parameter_t *
00135 jackctl_get_parameter(
00136 const JSList * parameters_list,
00137 const char * parameter_name)
00138 {
00139 while (parameters_list)
00140 {
00141 if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
00142 {
00143 return (jackctl_parameter_t *)parameters_list->data;
00144 }
00145
00146 parameters_list = jack_slist_next(parameters_list);
00147 }
00148
00149 return NULL;
00150 }
00151
00152 int main(int argc, char* argv[])
00153 {
00154 jackctl_server_t * server_ctl;
00155 const JSList * server_parameters;
00156 const char* server_name = "default";
00157 jackctl_driver_t * driver_ctl;
00158 const char *options = "-ad:P:uvrshVRL:STFl:t:mn:p:";
00159 struct option long_options[] = {
00160 { "driver", 1, 0, 'd' },
00161 { "verbose", 0, 0, 'v' },
00162 { "help", 0, 0, 'h' },
00163 { "port-max", 1, 0, 'p' },
00164 { "no-mlock", 0, 0, 'm' },
00165 { "name", 0, 0, 'n' },
00166 { "unlock", 0, 0, 'u' },
00167 { "realtime", 0, 0, 'R' },
00168 { "replace-registry", 0, 0, 'r' },
00169 { "loopback", 0, 0, 'L' },
00170 { "realtime-priority", 1, 0, 'P' },
00171 { "timeout", 1, 0, 't' },
00172 { "temporary", 0, 0, 'T' },
00173 { "version", 0, 0, 'V' },
00174 { "silent", 0, 0, 's' },
00175 { "sync", 0, 0, 'S' },
00176 { 0, 0, 0, 0 }
00177 };
00178 int i,opt = 0;
00179 int option_index = 0;
00180 bool seen_driver = false;
00181 char *driver_name = NULL;
00182 char **driver_args = NULL;
00183 int driver_nargs = 1;
00184 int port_max = 512;
00185 int do_mlock = 1;
00186 int do_unlock = 0;
00187 bool show_version = false;
00188 sigset_t signals;
00189 jackctl_parameter_t* param;
00190 union jackctl_parameter_value value;
00191
00192 copyright(stdout);
00193
00194 server_ctl = jackctl_server_create();
00195 if (server_ctl == NULL) {
00196 fprintf(stderr, "Failed to create server object\n");
00197 return -1;
00198 }
00199
00200 server_parameters = jackctl_server_get_parameters(server_ctl);
00201
00202 opterr = 0;
00203 while (!seen_driver &&
00204 (opt = getopt_long(argc, argv, options,
00205 long_options, &option_index)) != EOF) {
00206 switch (opt) {
00207
00208 case 'd':
00209 seen_driver = true;
00210 driver_name = optarg;
00211 break;
00212
00213 case 'p':
00214 port_max = (unsigned int)atol(optarg);
00215 break;
00216
00217 case 'm':
00218 do_mlock = 0;
00219 break;
00220
00221 case 'u':
00222 do_unlock = 1;
00223 break;
00224
00225 case 'v':
00226 param = jackctl_get_parameter(server_parameters, "verbose");
00227 if (param != NULL) {
00228 value.b = true;
00229 jackctl_parameter_set_value(param, &value);
00230 }
00231 break;
00232
00233 case 's':
00234 jack_set_error_function(silent_jack_error_callback);
00235 break;
00236
00237 case 'S':
00238 param = jackctl_get_parameter(server_parameters, "sync");
00239 if (param != NULL) {
00240 value.b = true;
00241 jackctl_parameter_set_value(param, &value);
00242 }
00243 break;
00244
00245 case 'n':
00246 server_name = optarg;
00247 param = jackctl_get_parameter(server_parameters, "name");
00248 if (param != NULL) {
00249 strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
00250 jackctl_parameter_set_value(param, &value);
00251 }
00252 break;
00253
00254 case 'P':
00255 param = jackctl_get_parameter(server_parameters, "realtime-priority");
00256 if (param != NULL) {
00257 value.i = atoi(optarg);
00258 jackctl_parameter_set_value(param, &value);
00259 }
00260 break;
00261
00262 case 'r':
00263 param = jackctl_get_parameter(server_parameters, "replace-registry");
00264 if (param != NULL) {
00265 value.b = true;
00266 jackctl_parameter_set_value(param, &value);
00267 }
00268 break;
00269
00270 case 'R':
00271 param = jackctl_get_parameter(server_parameters, "realtime");
00272 if (param != NULL) {
00273 value.b = true;
00274 jackctl_parameter_set_value(param, &value);
00275 }
00276 break;
00277
00278 case 'L':
00279 param = jackctl_get_parameter(server_parameters, "loopback-ports");
00280 if (param != NULL) {
00281 value.ui = atoi(optarg);
00282 jackctl_parameter_set_value(param, &value);
00283 }
00284 break;
00285
00286 case 'T':
00287 param = jackctl_get_parameter(server_parameters, "temporary");
00288 if (param != NULL) {
00289 value.b = true;
00290 jackctl_parameter_set_value(param, &value);
00291 }
00292 break;
00293
00294 case 't':
00295 param = jackctl_get_parameter(server_parameters, "client-timeout");
00296 if (param != NULL) {
00297 value.i = atoi(optarg);
00298 jackctl_parameter_set_value(param, &value);
00299 }
00300 break;
00301
00302 case 'V':
00303 show_version = true;
00304 break;
00305
00306 default:
00307 fprintf(stderr, "unknown option character %c\n", optopt);
00308
00309 case 'h':
00310 usage(stdout);
00311 goto fail_free;
00312 }
00313 }
00314
00315 if (show_version) {
00316 printf("jackdmp version" VERSION
00317 "\n");
00318 return -1;
00319 }
00320
00321 if (!seen_driver) {
00322 usage(stderr);
00323 goto fail_free;
00324 }
00325
00326 driver_ctl = jackctl_server_get_driver(server_ctl, driver_name);
00327 if (driver_ctl == NULL) {
00328 fprintf(stderr, "Unkown driver \"%s\"\n", driver_name);
00329 goto fail_free;
00330 }
00331
00332 if (optind < argc) {
00333 driver_nargs = 1 + argc - optind;
00334 } else {
00335 driver_nargs = 1;
00336 }
00337
00338 if (driver_nargs == 0) {
00339 fprintf(stderr, "No driver specified ... hmm. JACK won't do"
00340 " anything when run like this.\n");
00341 goto fail_free;
00342 }
00343
00344 driver_args = (char **) malloc(sizeof(char *) * driver_nargs);
00345 driver_args[0] = driver_name;
00346
00347 for (i = 1; i < driver_nargs; i++) {
00348 driver_args[i] = argv[optind++];
00349 }
00350
00351 if (jackctl_parse_driver_params(driver_ctl, driver_nargs, driver_args)) {
00352 goto fail_free;
00353 }
00354
00355 if (!jackctl_server_start(server_ctl, driver_ctl)) {
00356 fprintf(stderr, "Failed to start server\n");
00357 goto fail_free;
00358 }
00359
00360 notify_server_start(server_name);
00361
00362
00363 signals = jackctl_setup_signals(0);
00364 jackctl_wait_signals(signals);
00365
00366 if (!jackctl_server_stop(server_ctl))
00367 fprintf(stderr, "Cannot stop server...\n");
00368
00369 fail_free:
00370
00371 jackctl_server_destroy(server_ctl);
00372 notify_server_stop(server_name);
00373 return 1;
00374 }