25 #include <sys/types.h>
34 #include "JackConstants.h"
35 #include "JackPlatformPlug.h"
37 #include "JackControlAPIAndroid.h"
40 #if defined(JACK_DBUS) && defined(__linux__)
41 #include <dbus/dbus.h>
42 #include "audio_reserve.h"
53 #include <CoreFoundation/CFNotificationCenter.h>
54 #include <CoreFoundation/CoreFoundation.h>
56 static void notify_server_start(
const char* server_name)
59 CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
60 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
61 CFSTR(
"com.grame.jackserver.start"),
64 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
68 static void notify_server_stop(
const char* server_name)
71 CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
72 CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
73 CFSTR(
"com.grame.jackserver.stop"),
76 kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
82 static void notify_server_start(
const char* server_name)
84 static void notify_server_stop(
const char* server_name)
89 static void copyright(FILE* file)
91 fprintf(file,
"jackdmp " VERSION
"\n"
92 "Copyright 2001-2005 Paul Davis and others.\n"
93 "Copyright 2004-2014 Grame.\n"
94 "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
95 "This is free software, and you are welcome to redistribute it\n"
96 "under certain conditions; see the file COPYING for details\n");
107 node_ptr = jack_slist_next(node_ptr);
121 node_ptr = jack_slist_next(node_ptr);
129 while (parameters_list) {
133 parameters_list = jack_slist_next(parameters_list);
140 static void jackctl_server_switch_master_dummy(
jackctl_server_t * server_ctl,
char * master_driver_name)
142 static bool is_dummy_driver =
false;
143 if(!strcmp(master_driver_name,
"dummy")) {
147 if(is_dummy_driver) {
148 is_dummy_driver =
false;
149 driver_ctr = jackctl_server_get_driver(server_ctl, master_driver_name);
151 is_dummy_driver =
true;
152 driver_ctr = jackctl_server_get_driver(server_ctl,
"dummy");
162 fprintf(file,
"Available backends:\n");
167 node_ptr = jack_slist_next(node_ptr);
176 fprintf(file,
"Available internals:\n");
181 node_ptr = jack_slist_next(node_ptr);
189 const JSList * server_parameters;
194 "Usage: jackdmp [ --no-realtime OR -r ]\n"
195 " [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
196 " (the two previous arguments are mutually exclusive. The default is --realtime)\n"
197 " [ --name OR -n server-name ]\n"
198 " [ --timeout OR -t client-timeout-in-msecs ]\n"
199 " [ --loopback OR -L loopback-port-number ]\n"
200 " [ --port-max OR -p maximum-number-of-ports]\n"
201 " [ --slave-backend OR -X slave-backend-name ]\n"
202 " [ --internal-client OR -I internal-client-name ]\n"
203 " [ --verbose OR -v ]\n"
205 " [ --clocksource OR -c [ h(pet) | s(ystem) ]\n"
207 " [ --autoconnect OR -a <modechar>]\n");
210 param = jackctl_get_parameter(server_parameters,
"self-connect-mode");
212 " where <modechar> is one of:\n");
217 if (value.c == JACK_DEFAULT_SELF_CONNECT_MODE)
219 fprintf(file,
" (default)");
225 " [ --replace-registry ]\n"
226 " [ --silent OR -s ]\n"
227 " [ --sync OR -S ]\n"
228 " [ --temporary OR -T ]\n"
229 " [ --version OR -V ]\n"
230 " -d master-backend-name [ ... master-backend args ... ]\n"
231 " jackdmp -d master-backend-name --help\n"
232 " to display options for each master backend\n\n");
235 print_server_drivers(server, file);
236 print_server_internals(server, file);
241 extern "C" void silent_jack_error_callback(
const char *desc);
243 int main(
int argc,
char** argv)
246 const JSList * server_parameters;
247 const char* server_name = JACK_DEFAULT_SERVER_NAME;
250 int replace_registry = 0;
251 const char *options =
"-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
258 struct option long_options[] = {
260 {
"clock-source", 1, 0,
'c' },
262 {
"loopback-driver", 1, 0,
'L' },
263 {
"audio-driver", 1, 0,
'd' },
264 {
"midi-driver", 1, 0,
'X' },
265 {
"internal-client", 1, 0,
'I' },
266 {
"verbose", 0, 0,
'v' },
267 {
"help", 0, 0,
'h' },
268 {
"port-max", 1, 0,
'p' },
269 {
"no-mlock", 0, 0,
'm' },
270 {
"name", 1, 0,
'n' },
271 {
"unlock", 0, 0,
'u' },
272 {
"realtime", 0, 0,
'R' },
273 {
"no-realtime", 0, 0,
'r' },
274 {
"replace-registry", 0, &replace_registry, 0 },
275 {
"loopback", 0, 0,
'L' },
276 {
"realtime-priority", 1, 0,
'P' },
277 {
"timeout", 1, 0,
't' },
278 {
"temporary", 0, 0,
'T' },
279 {
"version", 0, 0,
'V' },
280 {
"silent", 0, 0,
's' },
281 {
"sync", 0, 0,
'S' },
282 {
"autoconnect", 1, 0,
'a' },
287 int option_index = 0;
288 char* master_driver_name = NULL;
289 char** master_driver_args = NULL;
290 int master_driver_nargs = 1;
292 bool show_version =
false;
297 std::list<char*> internals_list;
298 std::list<char*> slaves_list;
299 std::list<char*>::iterator it;
302 int return_value = -1;
303 bool notify_sent =
false;
306 #if defined(JACK_DBUS) && defined(__linux__)
311 if (server_ctl == NULL) {
312 fprintf(stderr,
"Failed to create server object\n");
319 while (!master_driver_name &&
320 (opt = getopt_long(argc, argv, options,
321 long_options, &option_index)) != EOF) {
326 param = jackctl_get_parameter(server_parameters,
"clock-source");
328 if (tolower (optarg[0]) ==
'h') {
329 value.ui = JACK_TIMER_HPET;
331 }
else if (tolower (optarg[0]) ==
'c') {
336 value.ui = JACK_TIMER_SYSTEM_CLOCK;
338 }
else if (tolower (optarg[0]) ==
's') {
339 value.ui = JACK_TIMER_SYSTEM_CLOCK;
342 usage(stdout, server_ctl);
350 param = jackctl_get_parameter(server_parameters,
"self-connect-mode");
352 bool value_valid =
false;
355 if( value.c == optarg[0] )
363 usage(stdout, server_ctl);
370 master_driver_name = optarg;
374 loopback = atoi(optarg);
378 slaves_list.push_back(optarg);
382 internals_list.push_back(optarg);
386 param = jackctl_get_parameter(server_parameters,
"port-max");
388 value.ui = atoi(optarg);
400 param = jackctl_get_parameter(server_parameters,
"verbose");
412 param = jackctl_get_parameter(server_parameters,
"sync");
420 server_name = optarg;
421 param = jackctl_get_parameter(server_parameters,
"name");
429 param = jackctl_get_parameter(server_parameters,
"realtime-priority");
431 value.i = atoi(optarg);
437 param = jackctl_get_parameter(server_parameters,
"realtime");
445 param = jackctl_get_parameter(server_parameters,
"realtime");
453 param = jackctl_get_parameter(server_parameters,
"temporary");
461 param = jackctl_get_parameter(server_parameters,
"client-timeout");
463 value.i = atoi(optarg);
473 fprintf(stderr,
"unknown option character %c\n", optopt);
477 usage(stdout, server_ctl);
483 param = jackctl_get_parameter(server_parameters,
"replace-registry");
485 value.b = replace_registry;
490 printf(
"jackdmp version " VERSION
491 " tmpdir " jack_server_dir
493 "\n", JACK_PROTOCOL_VERSION);
497 if (!master_driver_name) {
498 usage(stderr, server_ctl,
false);
503 master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
504 if (master_driver_ctl == NULL) {
505 fprintf(stderr,
"Unknown driver \"%s\"\n", master_driver_name);
510 fprintf(stderr,
"Driver \"%s\" is not a master \n", master_driver_name);
515 master_driver_nargs = 1 + argc - optind;
517 master_driver_nargs = 1;
520 if (master_driver_nargs == 0) {
521 fprintf(stderr,
"No driver specified ... hmm. JACK won't do"
522 " anything when run like this.\n");
526 master_driver_args = (
char **) malloc(
sizeof(
char *) * master_driver_nargs);
527 master_driver_args[0] = master_driver_name;
529 for (i = 1; i < master_driver_nargs; i++) {
530 master_driver_args[
i] = argv[optind++];
542 fprintf(stderr,
"Failed to open server\n");
547 for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
548 jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
549 if (slave_driver_ctl == NULL) {
550 fprintf(stderr,
"Unknown driver \"%s\"\n", *it);
554 fprintf(stderr,
"Driver \"%s\" is not a slave \n", *it);
558 fprintf(stderr,
"Driver \"%s\" cannot be loaded\n", *it);
565 loopback_driver_ctl = jackctl_server_get_driver(server_ctl,
"loopback");
567 if (loopback_driver_ctl != NULL) {
569 param = jackctl_get_parameter(loopback_parameters,
"channels");
575 fprintf(stderr,
"Driver \"loopback\" cannot be loaded\n");
579 fprintf(stderr,
"Driver \"loopback\" not found\n");
586 fprintf(stderr,
"Failed to start server\n");
591 for (it = internals_list.begin(); it != internals_list.end(); it++) {
592 jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
593 if (internal_driver_ctl == NULL) {
594 fprintf(stderr,
"Unknown internal \"%s\"\n", *it);
598 fprintf(stderr,
"Internal client \"%s\" cannot be loaded\n", *it);
603 notify_server_start(server_name);
611 int signal = jackctl_wait_signals_and_return(sigmask);
612 if (signal == SIGUSR2) {
613 jackctl_server_switch_master_dummy(server_ctl, master_driver_name);
624 fprintf(stderr,
"Cannot stop server...\n");
628 if (loopback > 0 && loopback_driver_ctl) {
632 for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
633 jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
634 if (slave_driver_ctl) {
640 for (it = internals_list.begin(); it != internals_list.end(); it++) {
641 jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
642 if (internal_driver_ctl) {
651 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 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)