common/Jackdmp.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <iostream>
  22 #include <assert.h>
  23 #include <cassert>
  24 #include <csignal>
  25 #include <sys/types.h>
  26 #include <getopt.h>
  27 #include <cstring>
  28 #include <cstdio>
  29
  30 #include "types.h"
  31 #include "jack.h"
  32 #include "JackConstants.h"
  33 #include "JackDriverLoader.h"
  34
  35 #if defined(JACK_DBUS) && defined(__linux__)
  36 #include <dbus/dbus.h>
  37 #include "audio_reserve.h"
  38 #endif
  39
  40 /*
  41 This is a simple port of the old jackdmp.cpp file to use the new Jack 2.0 control API. Available options for the server
  42 are "hard-coded" in the source. A much better approach would be to use the control API to:
  43 - dynamically retrieve available server parameters and then prepare to parse them
  44 - get available drivers and their possible parameters, then prepare to parse them.
  45 */
  46
  47 #ifdef __APPLE__
  48 #include <CoreFoundation/CFNotificationCenter.h>
  49 #include <CoreFoundation/CoreFoundation.h>
  50
  51 static void notify_server_start(const char* server_name)
  52 {
  53     // Send notification to be used in the JackRouter plugin
  54     CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
  55     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
  56             CFSTR("com.grame.jackserver.start"),
  57             ref,
  58             NULL,
  59             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
  60     CFRelease(ref);
  61 }
  62
  63 static void notify_server_stop(const char* server_name)
  64 {
  65     // Send notification to be used in the JackRouter plugin
  66     CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
  67     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
  68             CFSTR("com.grame.jackserver.stop"),
  69             ref1,
  70             NULL,
  71             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
  72     CFRelease(ref1);
  73 }
  74
  75 #else
  76
  77 static void notify_server_start(const char* server_name)
  78 {}
  79 static void notify_server_stop(const char* server_name)
  80 {}
  81
  82 #endif
  83
  84 static void copyright(FILE* file)
  85 {
  86     fprintf(file, "jackdmp " VERSION "\n"
  87             "Copyright 2001-2005 Paul Davis and others.\n"
  88             "Copyright 2004-2009 Grame.\n"
  89             "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
  90             "This is free software, and you are welcome to redistribute it\n"
  91             "under certain conditions; see the file COPYING for details\n");
  92 }
  93
  94 static void usage(FILE* file)
  95 {
  96     fprintf(file, "\n"
  97             "usage: jackdmp [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
  98             "               [ --name OR -n server-name ]\n"
  99             "               [ --timeout OR -t client-timeout-in-msecs ]\n"
 100             "               [ --loopback OR -L loopback-port-number ]\n"
 101             "               [ --midi OR -X midi-driver ]\n"
 102             "               [ --verbose OR -v ]\n"
 103 #ifdef __linux__
 104             "               [ --clocksource OR -c [ c(ycle) | h(pet) | s(ystem) ]\n"
 105 #endif
 106             "               [ --replace-registry OR -r ]\n"
 107             "               [ --silent OR -s ]\n"
 108             "               [ --sync OR -S ]\n"
 109             "               [ --temporary OR -T ]\n"
 110             "               [ --version OR -V ]\n"
 111             "         -d audio-driver [ ... driver args ... ]\n"
 112             "             where driver can be `alsa', `coreaudio', 'portaudio' or `dummy'\n"
 113             "       jackdmp -d driver --help\n"
 114             "             to display options for each driver\n\n");
 115 }
 116
 117 // To put in the control.h interface??
 118 static jackctl_driver_t *
 119 jackctl_server_get_driver(
 120     jackctl_server_t *server,
 121     const char *driver_name)
 122 {
 123     const JSList * node_ptr;
 124
 125     node_ptr = jackctl_server_get_drivers_list(server);
 126
 127     while (node_ptr)
 128     {
 129         if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
 130         {
 131             return (jackctl_driver_t *)node_ptr->data;
 132         }
 133
 134         node_ptr = jack_slist_next(node_ptr);
 135     }
 136
 137     return NULL;
 138 }
 139
 140 static jackctl_parameter_t *
 141 jackctl_get_parameter(
 142     const JSList * parameters_list,
 143     const char * parameter_name)
 144 {
 145     while (parameters_list)
 146     {
 147         if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
 148         {
 149             return (jackctl_parameter_t *)parameters_list->data;
 150         }
 151
 152         parameters_list = jack_slist_next(parameters_list);
 153     }
 154
 155     return NULL;
 156 }
 157
 158 int main(int argc, char* argv[])
 159 {
 160     jackctl_server_t * server_ctl;
 161     const JSList * server_parameters;
 162     const char* server_name = "default";
 163     jackctl_driver_t * audio_driver_ctl;
 164     jackctl_driver_t * midi_driver_ctl;
 165     jackctl_driver_t * loopback_driver_ctl;
 166
 167 #ifdef __linux__
 168     const char *options = "-ad:X:P:uvrshVRL:STFl:t:mn:p:c:L:";
 169 #else
 170     const char *options = "-ad:X:P:uvrshVRL:STFl:t:mn:p:L:";
 171 #endif
 172
 173     struct option long_options[] = {
 174 #ifdef __linux__
 175                                        { "clock-source", 1, 0, 'c' },
 176 #endif
 177                                        { "loopback-driver", 1, 0, 'L' },
 178                                        { "audio-driver", 1, 0, 'd' },
 179                                        { "midi-driver", 1, 0, 'X' },
 180                                        { "verbose", 0, 0, 'v' },
 181                                        { "help", 0, 0, 'h' },
 182                                        { "port-max", 1, 0, 'p' },
 183                                        { "no-mlock", 0, 0, 'm' },
 184                                        { "name", 0, 0, 'n' },
 185                                        { "unlock", 0, 0, 'u' },
 186                                        { "realtime", 0, 0, 'R' },
 187                                        { "replace-registry", 0, 0, 'r' },
 188                                        { "loopback", 0, 0, 'L' },
 189                                        { "realtime-priority", 1, 0, 'P' },
 190                                        { "timeout", 1, 0, 't' },
 191                                        { "temporary", 0, 0, 'T' },
 192                                        { "version", 0, 0, 'V' },
 193                                        { "silent", 0, 0, 's' },
 194                                        { "sync", 0, 0, 'S' },
 195                                        { 0, 0, 0, 0 }
 196                                    };
 197
 198     int i,opt = 0;
 199     int option_index = 0;
 200     bool seen_audio_driver = false;
 201     bool seen_midi_driver = false;
 202     char *audio_driver_name = NULL;
 203     char **audio_driver_args = NULL;
 204     int audio_driver_nargs = 1;
 205     char *midi_driver_name = NULL;
 206     char **midi_driver_args = NULL;
 207     int midi_driver_nargs = 1;
 208     int port_max = 512;
 209     int do_mlock = 1;
 210     int do_unlock = 0;
 211     int loopback = 0;
 212     bool show_version = false;
 213     sigset_t signals;
 214     jackctl_parameter_t* param;
 215     union jackctl_parameter_value value;
 216
 217     copyright(stdout);
 218 #if defined(JACK_DBUS) && defined(__linux__)
 219     server_ctl = jackctl_server_create(audio_acquire, audio_release);
 220 #else
 221     server_ctl = jackctl_server_create(NULL, NULL);
 222 #endif
 223     if (server_ctl == NULL) {
 224         fprintf(stderr, "Failed to create server object\n");
 225         return -1;
 226     }
 227
 228     server_parameters = jackctl_server_get_parameters(server_ctl);
 229     opterr = 0;
 230     while (!seen_audio_driver &&
 231             (opt = getopt_long(argc, argv, options,
 232                                long_options, &option_index)) != EOF) {
 233         switch (opt) {
 234
 235         #ifdef __linux__
 236             case 'c':
 237                 param = jackctl_get_parameter(server_parameters, "clock-source");
 238                 if (param != NULL) {
 239                     if (tolower (optarg[0]) == 'h') {
 240                         value.ui = JACK_TIMER_HPET;
 241                         jackctl_parameter_set_value(param, &value);
 242                     } else if (tolower (optarg[0]) == 'c') {
 243                         value.ui = JACK_TIMER_CYCLE_COUNTER;
 244                         jackctl_parameter_set_value(param, &value);
 245                     } else if (tolower (optarg[0]) == 's') {
 246                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
 247                         jackctl_parameter_set_value(param, &value);
 248                     } else {
 249                         usage(stdout);
 250                         goto fail_free1;
 251                     }
 252                 }
 253                 break;
 254         #endif
 255
 256             case 'd':
 257                 seen_audio_driver = true;
 258                 audio_driver_name = optarg;
 259                 break;
 260
 261             case 'L':
 262                 loopback = atoi(optarg);
 263                 break;
 264
 265             case 'X':
 266                 seen_midi_driver = true;
 267                 midi_driver_name = optarg;
 268                 break;
 269
 270             case 'p':
 271                 port_max = (unsigned int)atol(optarg);
 272                 break;
 273
 274             case 'm':
 275                 do_mlock = 0;
 276                 break;
 277
 278             case 'u':
 279                 do_unlock = 1;
 280                 break;
 281
 282             case 'v':
 283                 param = jackctl_get_parameter(server_parameters, "verbose");
 284                 if (param != NULL) {
 285                     value.b = true;
 286                     jackctl_parameter_set_value(param, &value);
 287                 }
 288                 break;
 289
 290             case 's':
 291                 jack_set_error_function(silent_jack_error_callback);
 292                 break;
 293
 294             case 'S':
 295                 param = jackctl_get_parameter(server_parameters, "sync");
 296                 if (param != NULL) {
 297                     value.b = true;
 298                     jackctl_parameter_set_value(param, &value);
 299                 }
 300                 break;
 301
 302             case 'n':
 303                 server_name = optarg;
 304                 param = jackctl_get_parameter(server_parameters, "name");
 305                 if (param != NULL) {
 306                     strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
 307                     jackctl_parameter_set_value(param, &value);
 308                 }
 309                 break;
 310
 311             case 'P':
 312                 param = jackctl_get_parameter(server_parameters, "realtime-priority");
 313                 if (param != NULL) {
 314                     value.i = atoi(optarg);
 315                     jackctl_parameter_set_value(param, &value);
 316                 }
 317                 break;
 318
 319             case 'r':
 320                 param = jackctl_get_parameter(server_parameters, "replace-registry");
 321                 if (param != NULL) {
 322                     value.b = true;
 323                     jackctl_parameter_set_value(param, &value);
 324                 }
 325                 break;
 326
 327             case 'R':
 328                 param = jackctl_get_parameter(server_parameters, "realtime");
 329                 if (param != NULL) {
 330                     value.b = true;
 331                     jackctl_parameter_set_value(param, &value);
 332                 }
 333                 break;
 334
 335             case 'T':
 336                 param = jackctl_get_parameter(server_parameters, "temporary");
 337                 if (param != NULL) {
 338                     value.b = true;
 339                     jackctl_parameter_set_value(param, &value);
 340                 }
 341                 break;
 342
 343             case 't':
 344                 param = jackctl_get_parameter(server_parameters, "client-timeout");
 345                 if (param != NULL) {
 346                     value.i = atoi(optarg);
 347                     jackctl_parameter_set_value(param, &value);
 348                 }
 349                 break;
 350
 351             case 'V':
 352                 show_version = true;
 353                 break;
 354
 355             default:
 356                 fprintf(stderr, "unknown option character %c\n", optopt);
 357                 /*fallthru*/
 358
 359             case 'h':
 360                 usage(stdout);
 361                 goto fail_free1;
 362         }
 363     }
 364
 365     if (show_version) {
 366         printf( "jackdmp version " VERSION
 367                 " tmpdir " jack_server_dir
 368                 " protocol %d"
 369                 "\n", JACK_PROTOCOL_VERSION);
 370         return -1;
 371     }
 372
 373     if (!seen_audio_driver) {
 374         usage(stderr);
 375         goto fail_free1;
 376     }
 377
 378     // Audio driver
 379     audio_driver_ctl = jackctl_server_get_driver(server_ctl, audio_driver_name);
 380     if (audio_driver_ctl == NULL) {
 381         fprintf(stderr, "Unkown driver \"%s\"\n", audio_driver_name);
 382         goto fail_free1;
 383     }
 384
 385     if (optind < argc) {
 386         audio_driver_nargs = 1 + argc - optind;
 387     } else {
 388         audio_driver_nargs = 1;
 389     }
 390
 391     if (audio_driver_nargs == 0) {
 392         fprintf(stderr, "No driver specified ... hmm. JACK won't do"
 393                 " anything when run like this.\n");
 394         goto fail_free1;
 395     }
 396
 397     audio_driver_args = (char **) malloc(sizeof(char *) * audio_driver_nargs);
 398     audio_driver_args[0] = audio_driver_name;
 399
 400     for (i = 1; i < audio_driver_nargs; i++) {
 401         audio_driver_args[i] = argv[optind++];
 402     }
 403
 404     if (jackctl_parse_driver_params(audio_driver_ctl, audio_driver_nargs, audio_driver_args)) {
 405         goto fail_free1;
 406     }
 407
 408     // Start server
 409     if (!jackctl_server_start(server_ctl, audio_driver_ctl)) {
 410         fprintf(stderr, "Failed to start server\n");
 411         goto fail_free1;
 412     }
 413
 414     // MIDI driver
 415     if (seen_midi_driver) {
 416
 417         midi_driver_ctl = jackctl_server_get_driver(server_ctl, midi_driver_name);
 418         if (midi_driver_ctl == NULL) {
 419             fprintf(stderr, "Unkown driver \"%s\"\n", midi_driver_name);
 420             goto fail_free2;
 421         }
 422
 423         jackctl_server_add_slave(server_ctl, midi_driver_ctl);
 424     }
 425
 426     // Loopback driver
 427     if (loopback > 0) {
 428         loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
 429         if (loopback_driver_ctl != NULL) {
 430             const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
 431             param = jackctl_get_parameter(loopback_parameters, "channels");
 432             if (param != NULL) {
 433                 value.ui = loopback;
 434                 jackctl_parameter_set_value(param, &value);
 435             }
 436             jackctl_server_add_slave(server_ctl, loopback_driver_ctl);
 437         }
 438     }
 439
 440     notify_server_start(server_name);
 441
 442     // Waits for signal
 443     signals = jackctl_setup_signals(0);
 444     jackctl_wait_signals(signals);
 445
 446     if (!jackctl_server_stop(server_ctl))
 447         fprintf(stderr, "Cannot stop server...\n");
 448
 449     jackctl_server_destroy(server_ctl);
 450     notify_server_stop(server_name);
 451     return 0;
 452
 453 fail_free1:
 454     jackctl_server_destroy(server_ctl);
 455     return -1;
 456
 457 fail_free2:
 458     jackctl_server_stop(server_ctl);
 459     jackctl_server_destroy(server_ctl);
 460     notify_server_stop(server_name);
 461     return -1;
 462 }