Jack2  1.9.11-RC1
JackServerGlobals.cpp
1 /*
2 Copyright (C) 2005 Grame
3 
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8 
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13 
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 
18 */
19 
20 #include "JackServerGlobals.h"
21 #include "JackLockedEngine.h"
22 #include "JackTools.h"
23 #include "shm.h"
24 #include <getopt.h>
25 #include <errno.h>
26 
27 static char* server_name = NULL;
28 
29 namespace Jack
30 {
31 
32 JackServer* JackServerGlobals::fInstance;
33 unsigned int JackServerGlobals::fUserCount;
34 std::map<std::string, JackDriverInfo*> JackServerGlobals::fSlavesList;
35 std::map<std::string, int> JackServerGlobals::fInternalsList;
36 
37 bool (* JackServerGlobals::on_device_acquire)(const char * device_name) = NULL;
38 void (* JackServerGlobals::on_device_release)(const char * device_name) = NULL;
39 
40 int JackServerGlobals::Start(const char* server_name,
41  jack_driver_desc_t* driver_desc,
42  JSList* driver_params,
43  int sync,
44  int temporary,
45  int time_out_ms,
46  int rt,
47  int priority,
48  int port_max,
49  int verbose,
50  jack_timer_type_t clock,
51  char self_connect_mode)
52 {
53  jack_log("Jackdmp: sync = %ld timeout = %ld rt = %ld priority = %ld verbose = %ld ", sync, time_out_ms, rt, priority, verbose);
54  new JackServer(sync, temporary, time_out_ms, rt, priority, port_max, verbose, clock, self_connect_mode, server_name); // Will setup fInstance and fUserCount globals
55  int res = fInstance->Open(driver_desc, driver_params);
56  return (res < 0) ? res : fInstance->Start();
57 }
58 
59 void JackServerGlobals::Stop()
60 {
61  jack_log("Jackdmp: server close");
62  fInstance->Stop();
63  fInstance->Close();
64 }
65 
66 void JackServerGlobals::Delete()
67 {
68  jack_log("Jackdmp: delete server");
69 
70  // Slave drivers
71  std::map<std::string, JackDriverInfo*>::iterator it1;
72  for (it1 = fSlavesList.begin(); it1 != fSlavesList.end(); it1++) {
73  JackDriverInfo* info = (*it1).second;
74  if (info) {
75  fInstance->RemoveSlave((info));
76  delete (info);
77  }
78  }
79  fSlavesList.clear();
80 
81  // Internal clients
82  std::map<std::string, int> ::iterator it2;
83  for (it2 = fInternalsList.begin(); it2 != fInternalsList.end(); it2++) {
84  int status;
85  int refnum = (*it2).second;
86  if (refnum > 0) {
87  // Client object is internally kept in JackEngine, and will be deallocated in InternalClientUnload
88  fInstance->GetEngine()->InternalClientUnload(refnum, &status);
89  }
90  }
91  fInternalsList.clear();
92 
93  delete fInstance;
94  fInstance = NULL;
95 }
96 
97 bool JackServerGlobals::Init()
98 {
99  int realtime = 0;
100  int client_timeout = 0; /* msecs; if zero, use period size. */
101  int realtime_priority = 10;
102  int verbose_aux = 0;
103  unsigned int port_max = 128;
104  int temporary = 0;
105 
106  int opt = 0;
107  int option_index = 0;
108  char *master_driver_name = NULL;
109  char **master_driver_args = NULL;
110  JSList* master_driver_params = NULL;
111  jack_driver_desc_t* driver_desc;
112  jack_timer_type_t clock_source = JACK_TIMER_SYSTEM_CLOCK;
113  int driver_nargs = 1;
114  JSList* drivers = NULL;
115  int loopback = 0;
116  int sync = 0;
117  int rc, i;
118  int res;
119  int replace_registry = 0;
120 
121  FILE* fp = 0;
122  char filename[255];
123  char buffer[255];
124  int argc = 0;
125  char* argv[32];
126 
127  // First user starts the server
128  if (fUserCount++ == 0) {
129 
130  jack_log("JackServerGlobals Init");
131 
132  const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
133  #ifdef __linux__
134  "c:"
135  #endif
136  ;
137 
138  struct option long_options[] = {
139  #ifdef __linux__
140  { "clock-source", 1, 0, 'c' },
141  #endif
142  { "loopback-driver", 1, 0, 'L' },
143  { "audio-driver", 1, 0, 'd' },
144  { "midi-driver", 1, 0, 'X' },
145  { "internal-client", 1, 0, 'I' },
146  { "verbose", 0, 0, 'v' },
147  { "help", 0, 0, 'h' },
148  { "port-max", 1, 0, 'p' },
149  { "no-mlock", 0, 0, 'm' },
150  { "name", 1, 0, 'n' },
151  { "unlock", 0, 0, 'u' },
152  { "realtime", 0, 0, 'R' },
153  { "no-realtime", 0, 0, 'r' },
154  { "replace-registry", 0, &replace_registry, 0 },
155  { "loopback", 0, 0, 'L' },
156  { "realtime-priority", 1, 0, 'P' },
157  { "timeout", 1, 0, 't' },
158  { "temporary", 0, 0, 'T' },
159  { "version", 0, 0, 'V' },
160  { "silent", 0, 0, 's' },
161  { "sync", 0, 0, 'S' },
162  { 0, 0, 0, 0 }
163  };
164 
165  snprintf(filename, 255, "%s/.jackdrc", getenv("HOME"));
166  fp = fopen(filename, "r");
167 
168  if (!fp) {
169  fp = fopen("/etc/jackdrc", "r");
170  }
171  // if still not found, check old config name for backwards compatability
172  if (!fp) {
173  fp = fopen("/etc/jackd.conf", "r");
174  }
175 
176  argc = 0;
177  if (fp) {
178  res = fscanf(fp, "%s", buffer);
179  while (res != 0 && res != EOF) {
180  argv[argc] = (char*)malloc(64);
181  strcpy(argv[argc], buffer);
182  res = fscanf(fp, "%s", buffer);
183  argc++;
184  }
185  fclose(fp);
186  }
187 
188  /*
189  For testing
190  int argc = 15;
191  char* argv[] = {"jackdmp", "-R", "-v", "-d", "coreaudio", "-p", "512", "-d", "~:Aggregate:0", "-r", "48000", "-i", "2", "-o", "2" };
192  */
193 
194  opterr = 0;
195  optind = 1; // Important : to reset argv parsing
196 
197  while (!master_driver_name &&
198  (opt = getopt_long(argc, argv, options, long_options, &option_index)) != EOF) {
199 
200  switch (opt) {
201 
202  case 'c':
203  if (tolower (optarg[0]) == 'h') {
204  clock_source = JACK_TIMER_HPET;
205  } else if (tolower (optarg[0]) == 'c') {
206  /* For backwards compatibility with scripts, allow
207  * the user to request the cycle clock on the
208  * command line, but use the system clock instead
209  */
210  clock_source = JACK_TIMER_SYSTEM_CLOCK;
211  } else if (tolower (optarg[0]) == 's') {
212  clock_source = JACK_TIMER_SYSTEM_CLOCK;
213  } else {
214  jack_error("unknown option character %c", optopt);
215  }
216  break;
217 
218  case 'd':
219  master_driver_name = optarg;
220  break;
221 
222  case 'L':
223  loopback = atoi(optarg);
224  break;
225 
226  case 'X':
227  fSlavesList[optarg] = NULL;
228  break;
229 
230  case 'I':
231  fInternalsList[optarg] = -1;
232  break;
233 
234  case 'p':
235  port_max = (unsigned int)atol(optarg);
236  break;
237 
238  case 'm':
239  break;
240 
241  case 'u':
242  break;
243 
244  case 'v':
245  verbose_aux = 1;
246  break;
247 
248  case 'S':
249  sync = 1;
250  break;
251 
252  case 'n':
253  server_name = optarg;
254  break;
255 
256  case 'P':
257  realtime_priority = atoi(optarg);
258  break;
259 
260  case 'r':
261  realtime = 0;
262  break;
263 
264  case 'R':
265  realtime = 1;
266  break;
267 
268  case 'T':
269  temporary = 1;
270  break;
271 
272  case 't':
273  client_timeout = atoi(optarg);
274  break;
275 
276  default:
277  jack_error("unknown option character %c", optopt);
278  break;
279  }
280  }
281 
282  drivers = jack_drivers_load(drivers);
283  if (!drivers) {
284  jack_error("jackdmp: no drivers found; exiting");
285  goto error;
286  }
287 
288  driver_desc = jack_find_driver_descriptor(drivers, master_driver_name);
289  if (!driver_desc) {
290  jack_error("jackdmp: unknown master driver '%s'", master_driver_name);
291  goto error;
292  }
293 
294  if (optind < argc) {
295  driver_nargs = 1 + argc - optind;
296  } else {
297  driver_nargs = 1;
298  }
299 
300  if (driver_nargs == 0) {
301  jack_error("No driver specified ... hmm. JACK won't do"
302  " anything when run like this.");
303  goto error;
304  }
305 
306  master_driver_args = (char**)malloc(sizeof(char*) * driver_nargs);
307  master_driver_args[0] = master_driver_name;
308 
309  for (i = 1; i < driver_nargs; i++) {
310  master_driver_args[i] = argv[optind++];
311  }
312 
313  if (jack_parse_driver_params(driver_desc, driver_nargs, master_driver_args, &master_driver_params)) {
314  goto error;
315  }
316 
317 #ifndef WIN32
318  if (server_name == NULL) {
319  server_name = (char*)JackTools::DefaultServerName();
320  }
321 #endif
322 
323  rc = jack_register_server(server_name, false);
324  switch (rc) {
325  case EEXIST:
326  jack_error("`%s' server already active", server_name);
327  goto error;
328  case ENOSPC:
329  jack_error("too many servers already active");
330  goto error;
331  case ENOMEM:
332  jack_error("no access to shm registry");
333  goto error;
334  default:
335  jack_info("server `%s' registered", server_name);
336  }
337 
338  /* clean up shared memory and files from any previous instance of this server name */
339  jack_cleanup_shm();
340  JackTools::CleanupFiles(server_name);
341 
342  if (!realtime && client_timeout == 0) {
343  client_timeout = 500; /* 0.5 sec; usable when non realtime. */
344  }
345 
346  for (i = 0; i < argc; i++) {
347  free(argv[i]);
348  }
349 
350  int res = Start(server_name, driver_desc, master_driver_params, sync, temporary, client_timeout, realtime, realtime_priority, port_max, verbose_aux, clock_source, JACK_DEFAULT_SELF_CONNECT_MODE);
351  if (res < 0) {
352  jack_error("Cannot start server... exit");
353  Delete();
354  jack_cleanup_shm();
355  JackTools::CleanupFiles(server_name);
356  jack_unregister_server(server_name);
357  goto error;
358  }
359 
360  // Slave drivers
361  std::map<std::string, JackDriverInfo*>::iterator it1;
362  for (it1 = fSlavesList.begin(); it1 != fSlavesList.end(); it1++) {
363  const char* name = ((*it1).first).c_str();
364  driver_desc = jack_find_driver_descriptor(drivers, name);
365  if (!driver_desc) {
366  jack_error("jackdmp: unknown slave driver '%s'", name);
367  } else {
368  (*it1).second = fInstance->AddSlave(driver_desc, NULL);
369  }
370  }
371 
372  // Loopback driver
373  if (loopback > 0) {
374  driver_desc = jack_find_driver_descriptor(drivers, "loopback");
375  if (!driver_desc) {
376  jack_error("jackdmp: unknown driver '%s'", "loopback");
377  } else {
378  fSlavesList["loopback"] = fInstance->AddSlave(driver_desc, NULL);
379  }
380  }
381 
382  // Internal clients
383  std::map<std::string, int>::iterator it2;
384  for (it2 = fInternalsList.begin(); it2 != fInternalsList.end(); it2++) {
385  int status, refnum;
386  const char* name = ((*it2).first).c_str();
387  fInstance->InternalClientLoad2(name, name, NULL, JackNullOption, &refnum, -1, &status);
388  (*it2).second = refnum;
389  }
390  }
391 
392  if (master_driver_params) {
393  jack_free_driver_params(master_driver_params);
394  }
395  return true;
396 
397 error:
398  jack_log("JackServerGlobals Init error");
399  if (master_driver_params) {
400  jack_free_driver_params(master_driver_params);
401  }
402  Destroy();
403  return false;
404 }
405 
406 void JackServerGlobals::Destroy()
407 {
408  if (--fUserCount == 0) {
409  jack_log("JackServerGlobals Destroy");
410  Stop();
411  Delete();
412  jack_cleanup_shm();
413  JackTools::CleanupFiles(server_name);
414  jack_unregister_server(server_name);
415  }
416 }
417 
418 } // end of namespace
419 
420 
SERVER_EXPORT void jack_error(const char *fmt,...)
Definition: JackError.cpp:92
SERVER_EXPORT void jack_info(const char *fmt,...)
Definition: JackError.cpp:100
Definition: getopt.h:84
SERVER_EXPORT void jack_log(const char *fmt,...)
Definition: JackError.cpp:108