Jack2  1.9.8
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 #include <list>
30 
31 #include "types.h"
32 #include "jack.h"
33 #include "JackConstants.h"
34 #include "JackDriverLoader.h"
35 
36 #if defined(JACK_DBUS) && defined(__linux__)
37 #include <dbus/dbus.h>
38 #include "audio_reserve.h"
39 #endif
40 
41 /*
42 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
43 are "hard-coded" in the source. A much better approach would be to use the control API to:
44 - dynamically retrieve available server parameters and then prepare to parse them
45 - get available drivers and their possible parameters, then prepare to parse them.
46 */
47 
48 #ifdef __APPLE__
49 #include <CoreFoundation/CFNotificationCenter.h>
50 #include <CoreFoundation/CoreFoundation.h>
51 
52 static void notify_server_start(const char* server_name)
53 {
54  // Send notification to be used in the JackRouter plugin
55  CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
56  CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
57  CFSTR("com.grame.jackserver.start"),
58  ref,
59  NULL,
60  kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
61  CFRelease(ref);
62 }
63 
64 static void notify_server_stop(const char* server_name)
65 {
66  // Send notification to be used in the JackRouter plugin
67  CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
68  CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
69  CFSTR("com.grame.jackserver.stop"),
70  ref1,
71  NULL,
72  kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
73  CFRelease(ref1);
74 }
75 
76 #else
77 
78 static void notify_server_start(const char* server_name)
79 {}
80 static void notify_server_stop(const char* server_name)
81 {}
82 
83 #endif
84 
85 static void copyright(FILE* file)
86 {
87  fprintf(file, "jackdmp " VERSION "\n"
88  "Copyright 2001-2005 Paul Davis and others.\n"
89  "Copyright 2004-2011 Grame.\n"
90  "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
91  "This is free software, and you are welcome to redistribute it\n"
92  "under certain conditions; see the file COPYING for details\n");
93 }
94 
95 static void usage(FILE* file)
96 {
97  fprintf(file, "\n"
98  "usage: jackdmp [ --no-realtime OR -r ]\n"
99  " [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
100  " (the two previous arguments are mutually exclusive. The default is --realtime)\n"
101  " [ --name OR -n server-name ]\n"
102  " [ --timeout OR -t client-timeout-in-msecs ]\n"
103  " [ --loopback OR -L loopback-port-number ]\n"
104  " [ --port-max OR -p maximum-number-of-ports]\n"
105  " [ --slave-backend OR -X slave-backend-name ]\n"
106  " [ --internal-client OR -I internal-client-name ]\n"
107  " [ --verbose OR -v ]\n"
108 #ifdef __linux__
109  " [ --clocksource OR -c [ c(ycle) | h(pet) | s(ystem) ]\n"
110 #endif
111  " [ --replace-registry ]\n"
112  " [ --silent OR -s ]\n"
113  " [ --sync OR -S ]\n"
114  " [ --temporary OR -T ]\n"
115  " [ --version OR -V ]\n"
116  " -d master-backend-name [ ... master-backend args ... ]\n"
117 #ifdef __APPLE__
118  " Available master backends may include: coreaudio, dummy, net or netone.\n\n"
119 #endif
120 #ifdef WIN32
121  " Available master backends may include: portaudio, dummy, net or netone.\n\n"
122 #endif
123 #ifdef __linux__
124  " Available master backends may include: alsa, dummy, freebob, firewire, net or netone.\n\n"
125 #endif
126 #if defined(__sun__) || defined(sun)
127  " Available master backends may include: boomer, oss, dummy or net.\n\n"
128 #endif
129  " jackdmp -d master-backend-name --help\n"
130  " to display options for each master backend\n\n");
131 }
132 
133 // To put in the control.h interface??
134 static jackctl_driver_t *
135 jackctl_server_get_driver(
136  jackctl_server_t *server,
137  const char *driver_name)
138 {
139  const JSList * node_ptr;
140 
141  node_ptr = jackctl_server_get_drivers_list(server);
142 
143  while (node_ptr)
144  {
145  if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
146  {
147  return (jackctl_driver_t *)node_ptr->data;
148  }
149 
150  node_ptr = jack_slist_next(node_ptr);
151  }
152 
153  return NULL;
154 }
155 
156 static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
157 {
158  const JSList * node_ptr = jackctl_server_get_internals_list(server);
159 
160  while (node_ptr) {
161  if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
162  return (jackctl_internal_t *)node_ptr->data;
163  }
164  node_ptr = jack_slist_next(node_ptr);
165  }
166 
167  return NULL;
168 }
169 
170 static jackctl_parameter_t *
171 jackctl_get_parameter(
172  const JSList * parameters_list,
173  const char * parameter_name)
174 {
175  while (parameters_list)
176  {
177  if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
178  {
179  return (jackctl_parameter_t *)parameters_list->data;
180  }
181 
182  parameters_list = jack_slist_next(parameters_list);
183  }
184 
185  return NULL;
186 }
187 
188 int main(int argc, char** argv)
189 {
190  jackctl_server_t * server_ctl;
191  const JSList * server_parameters;
192  const char* server_name = "default";
193  jackctl_driver_t * master_driver_ctl;
194  jackctl_driver_t * loopback_driver_ctl = NULL;
195  int replace_registry = 0;
196 
197  const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
198 #ifdef __linux__
199  "c:"
200 #endif
201  ;
202 
203  struct option long_options[] = {
204 #ifdef __linux__
205  { "clock-source", 1, 0, 'c' },
206 #endif
207  { "loopback-driver", 1, 0, 'L' },
208  { "audio-driver", 1, 0, 'd' },
209  { "midi-driver", 1, 0, 'X' },
210  { "internal-client", 1, 0, 'I' },
211  { "verbose", 0, 0, 'v' },
212  { "help", 0, 0, 'h' },
213  { "port-max", 1, 0, 'p' },
214  { "no-mlock", 0, 0, 'm' },
215  { "name", 1, 0, 'n' },
216  { "unlock", 0, 0, 'u' },
217  { "realtime", 0, 0, 'R' },
218  { "no-realtime", 0, 0, 'r' },
219  { "replace-registry", 0, &replace_registry, 0 },
220  { "loopback", 0, 0, 'L' },
221  { "realtime-priority", 1, 0, 'P' },
222  { "timeout", 1, 0, 't' },
223  { "temporary", 0, 0, 'T' },
224  { "version", 0, 0, 'V' },
225  { "silent", 0, 0, 's' },
226  { "sync", 0, 0, 'S' },
227  { 0, 0, 0, 0 }
228  };
229 
230  int i,opt = 0;
231  int option_index = 0;
232  char* master_driver_name = NULL;
233  char** master_driver_args = NULL;
234  int master_driver_nargs = 1;
235  int do_mlock = 1;
236  int do_unlock = 0;
237  int loopback = 0;
238  bool show_version = false;
239  sigset_t signals;
240  jackctl_parameter_t* param;
241  union jackctl_parameter_value value;
242 
243  std::list<char*> internals_list;
244  std::list<char*> slaves_list;
245  std::list<char*>::iterator it;
246 
247  // Assume that we fail.
248  int return_value = -1;
249  bool notify_sent = false;
250 
251  copyright(stdout);
252 #if defined(JACK_DBUS) && defined(__linux__)
253  server_ctl = jackctl_server_create(audio_acquire, audio_release);
254 #else
255  server_ctl = jackctl_server_create(NULL, NULL);
256 #endif
257  if (server_ctl == NULL) {
258  fprintf(stderr, "Failed to create server object\n");
259  return -1;
260  }
261 
262  server_parameters = jackctl_server_get_parameters(server_ctl);
263 
264  opterr = 0;
265  while (!master_driver_name &&
266  (opt = getopt_long(argc, argv, options,
267  long_options, &option_index)) != EOF) {
268  switch (opt) {
269 
270  #ifdef __linux__
271  case 'c':
272  param = jackctl_get_parameter(server_parameters, "clock-source");
273  if (param != NULL) {
274  if (tolower (optarg[0]) == 'h') {
275  value.ui = JACK_TIMER_HPET;
276  jackctl_parameter_set_value(param, &value);
277  } else if (tolower (optarg[0]) == 'c') {
278  value.ui = JACK_TIMER_CYCLE_COUNTER;
279  jackctl_parameter_set_value(param, &value);
280  } else if (tolower (optarg[0]) == 's') {
281  value.ui = JACK_TIMER_SYSTEM_CLOCK;
282  jackctl_parameter_set_value(param, &value);
283  } else {
284  usage(stdout);
285  goto destroy_server;
286  }
287  }
288  break;
289  #endif
290 
291  case 'd':
292  master_driver_name = optarg;
293  break;
294 
295  case 'L':
296  loopback = atoi(optarg);
297  break;
298 
299  case 'X':
300  slaves_list.push_back(optarg);
301  break;
302 
303  case 'I':
304  internals_list.push_back(optarg);
305  break;
306 
307  case 'p':
308  param = jackctl_get_parameter(server_parameters, "port-max");
309  if (param != NULL) {
310  value.ui = atoi(optarg);
311  jackctl_parameter_set_value(param, &value);
312  }
313  break;
314 
315  case 'm':
316  do_mlock = 0;
317  break;
318 
319  case 'u':
320  do_unlock = 1;
321  break;
322 
323  case 'v':
324  param = jackctl_get_parameter(server_parameters, "verbose");
325  if (param != NULL) {
326  value.b = true;
327  jackctl_parameter_set_value(param, &value);
328  }
329  break;
330 
331  case 's':
332  jack_set_error_function(silent_jack_error_callback);
333  break;
334 
335  case 'S':
336  param = jackctl_get_parameter(server_parameters, "sync");
337  if (param != NULL) {
338  value.b = true;
339  jackctl_parameter_set_value(param, &value);
340  }
341  break;
342 
343  case 'n':
344  server_name = optarg;
345  param = jackctl_get_parameter(server_parameters, "name");
346  if (param != NULL) {
347  strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
348  jackctl_parameter_set_value(param, &value);
349  }
350  break;
351 
352  case 'P':
353  param = jackctl_get_parameter(server_parameters, "realtime-priority");
354  if (param != NULL) {
355  value.i = atoi(optarg);
356  jackctl_parameter_set_value(param, &value);
357  }
358  break;
359 
360  case 'r':
361  param = jackctl_get_parameter(server_parameters, "realtime");
362  if (param != NULL) {
363  value.b = false;
364  jackctl_parameter_set_value(param, &value);
365  }
366  break;
367 
368  case 'R':
369  param = jackctl_get_parameter(server_parameters, "realtime");
370  if (param != NULL) {
371  value.b = true;
372  jackctl_parameter_set_value(param, &value);
373  }
374  break;
375 
376  case 'T':
377  param = jackctl_get_parameter(server_parameters, "temporary");
378  if (param != NULL) {
379  value.b = true;
380  jackctl_parameter_set_value(param, &value);
381  }
382  break;
383 
384  case 't':
385  param = jackctl_get_parameter(server_parameters, "client-timeout");
386  if (param != NULL) {
387  value.i = atoi(optarg);
388  jackctl_parameter_set_value(param, &value);
389  }
390  break;
391 
392  case 'V':
393  show_version = true;
394  break;
395 
396  default:
397  fprintf(stderr, "unknown option character %c\n", optopt);
398  /*fallthru*/
399 
400  case 'h':
401  usage(stdout);
402  goto destroy_server;
403  }
404  }
405 
406  // Long option with no letter so treated separately
407  param = jackctl_get_parameter(server_parameters, "replace-registry");
408  if (param != NULL) {
409  value.b = replace_registry;
410  jackctl_parameter_set_value(param, &value);
411  }
412 
413  if (show_version) {
414  printf( "jackdmp version " VERSION
415  " tmpdir " jack_server_dir
416  " protocol %d"
417  "\n", JACK_PROTOCOL_VERSION);
418  return -1;
419  }
420 
421  if (!master_driver_name) {
422  usage(stderr);
423  goto destroy_server;
424  }
425 
426  // Master driver
427  master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
428  if (master_driver_ctl == NULL) {
429  fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name);
430  goto destroy_server;
431  }
432 
433  if (jackctl_driver_get_type(master_driver_ctl) != JackMaster) {
434  fprintf(stderr, "Driver \"%s\" is not a master \n", master_driver_name);
435  goto destroy_server;
436  }
437 
438  if (optind < argc) {
439  master_driver_nargs = 1 + argc - optind;
440  } else {
441  master_driver_nargs = 1;
442  }
443 
444  if (master_driver_nargs == 0) {
445  fprintf(stderr, "No driver specified ... hmm. JACK won't do"
446  " anything when run like this.\n");
447  goto destroy_server;
448  }
449 
450  master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs);
451  master_driver_args[0] = master_driver_name;
452 
453  for (i = 1; i < master_driver_nargs; i++) {
454  master_driver_args[i] = argv[optind++];
455  }
456 
457  if (jackctl_parse_driver_params(master_driver_ctl, master_driver_nargs, master_driver_args)) {
458  goto destroy_server;
459  }
460 
461  // Setup signals
462  signals = jackctl_setup_signals(0);
463 
464  // Open server
465  if (! jackctl_server_open(server_ctl, master_driver_ctl)) {
466  fprintf(stderr, "Failed to open server\n");
467  goto destroy_server;
468  }
469 
470  // Slave drivers
471  for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
472  jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
473  if (slave_driver_ctl == NULL) {
474  fprintf(stderr, "Unknown driver \"%s\"\n", *it);
475  goto close_server;
476  }
477  if (jackctl_driver_get_type(slave_driver_ctl) != JackSlave) {
478  fprintf(stderr, "Driver \"%s\" is not a slave \n", *it);
479  goto close_server;
480  }
481  if (!jackctl_server_add_slave(server_ctl, slave_driver_ctl)) {
482  fprintf(stderr, "Driver \"%s\" cannot be loaded\n", *it);
483  goto close_server;
484  }
485  }
486 
487  // Loopback driver
488  if (loopback > 0) {
489  loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
490 
491  if (loopback_driver_ctl != NULL) {
492  const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
493  param = jackctl_get_parameter(loopback_parameters, "channels");
494  if (param != NULL) {
495  value.ui = loopback;
496  jackctl_parameter_set_value(param, &value);
497  }
498  if (!jackctl_server_add_slave(server_ctl, loopback_driver_ctl)) {
499  fprintf(stderr, "Driver \"loopback\" cannot be loaded\n");
500  goto close_server;
501  }
502  } else {
503  fprintf(stderr, "Driver \"loopback\" not found\n");
504  goto close_server;
505  }
506  }
507 
508  // Start the server
509  if (!jackctl_server_start(server_ctl)) {
510  fprintf(stderr, "Failed to start server\n");
511  goto close_server;
512  }
513 
514  // Internal clients
515  for (it = internals_list.begin(); it != internals_list.end(); it++) {
516  jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
517  if (internal_driver_ctl == NULL) {
518  fprintf(stderr, "Unknown internal \"%s\"\n", *it);
519  goto stop_server;
520  }
521  if (!jackctl_server_load_internal(server_ctl, internal_driver_ctl)) {
522  fprintf(stderr, "Internal client \"%s\" cannot be loaded\n", *it);
523  goto stop_server;
524  }
525  }
526 
527  notify_server_start(server_name);
528  notify_sent = true;
529  return_value = 0;
530 
531  // Waits for signal
532  jackctl_wait_signals(signals);
533 
534  stop_server:
535  if (!jackctl_server_stop(server_ctl)) {
536  fprintf(stderr, "Cannot stop server...\n");
537  }
538 
539  close_server:
540  if (loopback > 0 && loopback_driver_ctl) {
541  jackctl_server_remove_slave(server_ctl, loopback_driver_ctl);
542  }
543  // Slave drivers
544  for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
545  jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
546  if (slave_driver_ctl)
547  jackctl_server_remove_slave(server_ctl, slave_driver_ctl);
548  }
549 
550  // Internal clients
551  for (it = internals_list.begin(); it != internals_list.end(); it++) {
552  jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
553  if (internal_driver_ctl)
554  jackctl_server_unload_internal(server_ctl, internal_driver_ctl);
555  }
556  jackctl_server_close(server_ctl);
557 
558  destroy_server:
559  jackctl_server_destroy(server_ctl);
560  if (notify_sent) {
561  notify_server_stop(server_name);
562  }
563  return return_value;
564 }