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 [ --no-realtime OR -r ]\n"
  98             "               [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
  99             "      (the two previous arguments are mutually exclusive. The default is --realtime)\n"
 100             "               [ --name OR -n server-name ]\n"
 101             "               [ --timeout OR -t client-timeout-in-msecs ]\n"
 102             "               [ --loopback OR -L loopback-port-number ]\n"
 103             "               [ --midi OR -X midi-driver ]\n"
 104             "               [ --verbose OR -v ]\n"
 105 #ifdef __linux__
 106             "               [ --clocksource OR -c [ c(ycle) | h(pet) | s(ystem) ]\n"
 107 #endif
 108             "               [ --replace-registry ]\n"
 109             "               [ --silent OR -s ]\n"
 110             "               [ --sync OR -S ]\n"
 111             "               [ --temporary OR -T ]\n"
 112             "               [ --version OR -V ]\n"
 113             "         -d backend [ ... backend args ... ]\n"
 114 #ifdef __APPLE__
 115             "               Available backends may include: coreaudio, dummy or net.\n\n"
 116 #endif
 117 #ifdef WIN32
 118             "               Available backends may include: portaudio, dummy or net.\n\n"
 119 #endif
 120 #ifdef __linux__
 121             "               Available backends may include: alsa, dummy, freebob, firewire, net, oss or sun.\n\n"
 122 #endif
 123 #if defined(__sun__) || defined(sun)
 124             "               Available backends may include: boomer, oss, dummy or net.\n\n"
 125 #endif
 126             "       jackdmp -d backend --help\n"
 127             "             to display options for each backend\n\n");
 128 }
 129
 130 // To put in the control.h interface??
 131 static jackctl_driver_t *
 132 jackctl_server_get_driver(
 133     jackctl_server_t *server,
 134     const char *driver_name)
 135 {
 136     const JSList * node_ptr;
 137
 138     node_ptr = jackctl_server_get_drivers_list(server);
 139
 140     while (node_ptr)
 141     {
 142         if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
 143         {
 144             return (jackctl_driver_t *)node_ptr->data;
 145         }
 146
 147         node_ptr = jack_slist_next(node_ptr);
 148     }
 149
 150     return NULL;
 151 }
 152
 153 static jackctl_parameter_t *
 154 jackctl_get_parameter(
 155     const JSList * parameters_list,
 156     const char * parameter_name)
 157 {
 158     while (parameters_list)
 159     {
 160         if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
 161         {
 162             return (jackctl_parameter_t *)parameters_list->data;
 163         }
 164
 165         parameters_list = jack_slist_next(parameters_list);
 166     }
 167
 168     return NULL;
 169 }
 170
 171 int main(int argc, char* argv[])
 172 {
 173     jackctl_server_t * server_ctl;
 174     const JSList * server_parameters;
 175     const char* server_name = "default";
 176     jackctl_driver_t * audio_driver_ctl;
 177     jackctl_driver_t * midi_driver_ctl;
 178     jackctl_driver_t * loopback_driver_ctl;
 179     int replace_registry = 0;
 180
 181 #ifdef __linux__
 182     const char *options = "-ad:X:P:uvshVrRL:STFl:t:mn:p:c:L:";
 183 #else
 184     const char *options = "-ad:X:P:uvshVrRL:STFl:t:mn:p:L:";
 185 #endif
 186
 187     struct option long_options[] = {
 188 #ifdef __linux__
 189                                        { "clock-source", 1, 0, 'c' },
 190 #endif
 191                                        { "loopback-driver", 1, 0, 'L' },
 192                                        { "audio-driver", 1, 0, 'd' },
 193                                        { "midi-driver", 1, 0, 'X' },
 194                                        { "verbose", 0, 0, 'v' },
 195                                        { "help", 0, 0, 'h' },
 196                                        { "port-max", 1, 0, 'p' },
 197                                        { "no-mlock", 0, 0, 'm' },
 198                                        { "name", 0, 0, 'n' },
 199                                        { "unlock", 0, 0, 'u' },
 200                                        { "realtime", 0, 0, 'R' },
 201                                        { "no-realtime", 0, 0, 'r' },
 202                                        { "replace-registry", 0, &replace_registry, 0 },
 203                                        { "loopback", 0, 0, 'L' },
 204                                        { "realtime-priority", 1, 0, 'P' },
 205                                        { "timeout", 1, 0, 't' },
 206                                        { "temporary", 0, 0, 'T' },
 207                                        { "version", 0, 0, 'V' },
 208                                        { "silent", 0, 0, 's' },
 209                                        { "sync", 0, 0, 'S' },
 210                                        { 0, 0, 0, 0 }
 211                                    };
 212
 213     int i,opt = 0;
 214     int option_index = 0;
 215     bool seen_audio_driver = false;
 216     bool seen_midi_driver = false;
 217     char *audio_driver_name = NULL;
 218     char **audio_driver_args = NULL;
 219     int audio_driver_nargs = 1;
 220     char *midi_driver_name = NULL;
 221     char **midi_driver_args = NULL;
 222     int midi_driver_nargs = 1;
 223     int port_max = 512;
 224     int do_mlock = 1;
 225     int do_unlock = 0;
 226     int loopback = 0;
 227     bool show_version = false;
 228     sigset_t signals;
 229     jackctl_parameter_t* param;
 230     union jackctl_parameter_value value;
 231
 232     copyright(stdout);
 233 #if defined(JACK_DBUS) && defined(__linux__)
 234     server_ctl = jackctl_server_create(audio_acquire, audio_release);
 235 #else
 236     server_ctl = jackctl_server_create(NULL, NULL);
 237 #endif
 238     if (server_ctl == NULL) {
 239         fprintf(stderr, "Failed to create server object\n");
 240         return -1;
 241     }
 242
 243     server_parameters = jackctl_server_get_parameters(server_ctl);
 244
 245     // Default setting
 246     param = jackctl_get_parameter(server_parameters, "realtime");
 247     if (param != NULL) {
 248         value.b = true;
 249         jackctl_parameter_set_value(param, &value);
 250     }
 251
 252     opterr = 0;
 253     while (!seen_audio_driver &&
 254             (opt = getopt_long(argc, argv, options,
 255                                long_options, &option_index)) != EOF) {
 256         switch (opt) {
 257
 258         #ifdef __linux__
 259             case 'c':
 260                 param = jackctl_get_parameter(server_parameters, "clock-source");
 261                 if (param != NULL) {
 262                     if (tolower (optarg[0]) == 'h') {
 263                         value.ui = JACK_TIMER_HPET;
 264                         jackctl_parameter_set_value(param, &value);
 265                     } else if (tolower (optarg[0]) == 'c') {
 266                         value.ui = JACK_TIMER_CYCLE_COUNTER;
 267                         jackctl_parameter_set_value(param, &value);
 268                     } else if (tolower (optarg[0]) == 's') {
 269                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
 270                         jackctl_parameter_set_value(param, &value);
 271                     } else {
 272                         usage(stdout);
 273                         goto fail_free1;
 274                     }
 275                 }
 276                 break;
 277         #endif
 278
 279             case 'd':
 280                 seen_audio_driver = true;
 281                 audio_driver_name = optarg;
 282                 break;
 283
 284             case 'L':
 285                 loopback = atoi(optarg);
 286                 break;
 287
 288             case 'X':
 289                 seen_midi_driver = true;
 290                 midi_driver_name = optarg;
 291                 break;
 292
 293             case 'p':
 294                 port_max = (unsigned int)atol(optarg);
 295                 break;
 296
 297             case 'm':
 298                 do_mlock = 0;
 299                 break;
 300
 301             case 'u':
 302                 do_unlock = 1;
 303                 break;
 304
 305             case 'v':
 306                 param = jackctl_get_parameter(server_parameters, "verbose");
 307                 if (param != NULL) {
 308                     value.b = true;
 309                     jackctl_parameter_set_value(param, &value);
 310                 }
 311                 break;
 312
 313             case 's':
 314                 jack_set_error_function(silent_jack_error_callback);
 315                 break;
 316
 317             case 'S':
 318                 param = jackctl_get_parameter(server_parameters, "sync");
 319                 if (param != NULL) {
 320                     value.b = true;
 321                     jackctl_parameter_set_value(param, &value);
 322                 }
 323                 break;
 324
 325             case 'n':
 326                 server_name = optarg;
 327                 param = jackctl_get_parameter(server_parameters, "name");
 328                 if (param != NULL) {
 329                     strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
 330                     jackctl_parameter_set_value(param, &value);
 331                 }
 332                 break;
 333
 334             case 'P':
 335                 param = jackctl_get_parameter(server_parameters, "realtime-priority");
 336                 if (param != NULL) {
 337                     value.i = atoi(optarg);
 338                     jackctl_parameter_set_value(param, &value);
 339                 }
 340                 break;
 341
 342             case 'r':
 343                 param = jackctl_get_parameter(server_parameters, "realtime");
 344                 if (param != NULL) {
 345                     value.b = false;
 346                     jackctl_parameter_set_value(param, &value);
 347                 }
 348                 break;
 349
 350             case 'R':
 351                 param = jackctl_get_parameter(server_parameters, "realtime");
 352                 if (param != NULL) {
 353                     value.b = true;
 354                     jackctl_parameter_set_value(param, &value);
 355                 }
 356                 break;
 357
 358             case 'T':
 359                 param = jackctl_get_parameter(server_parameters, "temporary");
 360                 if (param != NULL) {
 361                     value.b = true;
 362                     jackctl_parameter_set_value(param, &value);
 363                 }
 364                 break;
 365
 366             case 't':
 367                 param = jackctl_get_parameter(server_parameters, "client-timeout");
 368                 if (param != NULL) {
 369                     value.i = atoi(optarg);
 370                     jackctl_parameter_set_value(param, &value);
 371                 }
 372                 break;
 373
 374             case 'V':
 375                 show_version = true;
 376                 break;
 377
 378             default:
 379                 fprintf(stderr, "unknown option character %c\n", optopt);
 380                 /*fallthru*/
 381
 382             case 'h':
 383                 usage(stdout);
 384                 goto fail_free1;
 385         }
 386     }
 387
 388     // Long option with no letter so treated separately
 389     param = jackctl_get_parameter(server_parameters, "replace-registry");
 390     if (param != NULL) {
 391         value.b = replace_registry;
 392         jackctl_parameter_set_value(param, &value);
 393     }
 394
 395     if (show_version) {
 396         printf( "jackdmp version " VERSION
 397                 " tmpdir " jack_server_dir
 398                 " protocol %d"
 399                 "\n", JACK_PROTOCOL_VERSION);
 400         return -1;
 401     }
 402
 403     if (!seen_audio_driver) {
 404         usage(stderr);
 405         goto fail_free1;
 406     }
 407
 408     // Audio driver
 409     audio_driver_ctl = jackctl_server_get_driver(server_ctl, audio_driver_name);
 410     if (audio_driver_ctl == NULL) {
 411         fprintf(stderr, "Unkown driver \"%s\"\n", audio_driver_name);
 412         goto fail_free1;
 413     }
 414
 415     if (optind < argc) {
 416         audio_driver_nargs = 1 + argc - optind;
 417     } else {
 418         audio_driver_nargs = 1;
 419     }
 420
 421     if (audio_driver_nargs == 0) {
 422         fprintf(stderr, "No driver specified ... hmm. JACK won't do"
 423                 " anything when run like this.\n");
 424         goto fail_free1;
 425     }
 426
 427     audio_driver_args = (char **) malloc(sizeof(char *) * audio_driver_nargs);
 428     audio_driver_args[0] = audio_driver_name;
 429
 430     for (i = 1; i < audio_driver_nargs; i++) {
 431         audio_driver_args[i] = argv[optind++];
 432     }
 433
 434     if (jackctl_parse_driver_params(audio_driver_ctl, audio_driver_nargs, audio_driver_args)) {
 435         goto fail_free1;
 436     }
 437
 438     // Start server
 439     if (!jackctl_server_start(server_ctl, audio_driver_ctl)) {
 440         fprintf(stderr, "Failed to start server\n");
 441         goto fail_free1;
 442     }
 443
 444     // MIDI driver
 445     if (seen_midi_driver) {
 446
 447         midi_driver_ctl = jackctl_server_get_driver(server_ctl, midi_driver_name);
 448         if (midi_driver_ctl == NULL) {
 449             fprintf(stderr, "Unkown driver \"%s\"\n", midi_driver_name);
 450             goto fail_free2;
 451         }
 452
 453         jackctl_server_add_slave(server_ctl, midi_driver_ctl);
 454     }
 455
 456     // Loopback driver
 457     if (loopback > 0) {
 458         loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
 459         if (loopback_driver_ctl != NULL) {
 460             const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
 461             param = jackctl_get_parameter(loopback_parameters, "channels");
 462             if (param != NULL) {
 463                 value.ui = loopback;
 464                 jackctl_parameter_set_value(param, &value);
 465             }
 466             jackctl_server_add_slave(server_ctl, loopback_driver_ctl);
 467         }
 468     }
 469
 470     notify_server_start(server_name);
 471
 472     // Waits for signal
 473     signals = jackctl_setup_signals(0);
 474     jackctl_wait_signals(signals);
 475
 476     if (!jackctl_server_stop(server_ctl))
 477         fprintf(stderr, "Cannot stop server...\n");
 478
 479     jackctl_server_destroy(server_ctl);
 480     notify_server_stop(server_name);
 481     return 0;
 482
 483 fail_free1:
 484     jackctl_server_destroy(server_ctl);
 485     return -1;
 486
 487 fail_free2:
 488     jackctl_server_stop(server_ctl);
 489     jackctl_server_destroy(server_ctl);
 490     notify_server_stop(server_name);
 491     return -1;
 492 }