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