Jack2  1.9.9
JackDriverLoader.cpp
1 /*
2 Copyright (C) 2001-2005 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 "JackSystemDeps.h"
22 #include "JackDriverLoader.h"
23 #include "JackDriverInfo.h"
24 #include "JackConstants.h"
25 #include "JackError.h"
26 #include <getopt.h>
27 #include <stdio.h>
28 #include <errno.h>
29 #include <string.h>
30 
31 #ifndef WIN32
32 #include <dirent.h>
33 #endif
34 
35 #ifdef WIN32
36 
37 static char* locate_dll_driver_dir()
38 {
39 #ifdef _WIN64
40  HMODULE libjack_handle = LoadLibrary("libjackserver64.dll");
41 #else
42  HMODULE libjack_handle = LoadLibrary("libjackserver.dll");
43 #endif
44 
45  // For WIN32 ADDON_DIR is defined in JackConstants.h as relative path
46  char driver_dir_storage[512];
47  if (3 < GetModuleFileName(libjack_handle, driver_dir_storage, 512)) {
48  char *p = strrchr(driver_dir_storage, '\\');
49  if (p && (p != driver_dir_storage)) {
50  *p = 0;
51  }
52  jack_info("Drivers/internals found in : %s", driver_dir_storage);
53  strcat(driver_dir_storage, "/");
54  strcat(driver_dir_storage, ADDON_DIR);
55  FreeLibrary(libjack_handle);
56  return strdup(driver_dir_storage);
57  } else {
58  jack_error("Cannot get JACK dll directory : %d", GetLastError());
59  FreeLibrary(libjack_handle);
60  return NULL;
61  }
62 }
63 
64 static char* locate_driver_dir(HANDLE& file, WIN32_FIND_DATA& filedata)
65 {
66  // Search drivers/internals iin the same folder of "libjackserver.dll"
67  char* driver_dir = locate_dll_driver_dir();
68  char dll_filename[512];
69  snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);
70  file = (HANDLE)FindFirstFile(dll_filename, &filedata);
71 
72  if (file == INVALID_HANDLE_VALUE) {
73  jack_error("Drivers not found ");
74  free(driver_dir);
75  return NULL;
76  } else {
77  return driver_dir;
78  }
79 }
80 
81 #endif
82 
83 jack_driver_desc_t* jackctl_driver_get_desc(jackctl_driver_t * driver);
84 
85 void jack_print_driver_options(jack_driver_desc_t* desc, FILE* file)
86 {
87  unsigned long i;
88  char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];
89 
90  for (i = 0; i < desc->nparams; i++) {
91  switch (desc->params[i].type) {
92  case JackDriverParamInt:
93  sprintf (arg_default, "%" "i", desc->params[i].value.i);
94  break;
95  case JackDriverParamUInt:
96  sprintf (arg_default, "%" "u", desc->params[i].value.ui);
97  break;
98  case JackDriverParamChar:
99  sprintf (arg_default, "%c", desc->params[i].value.c);
100  break;
101  case JackDriverParamString:
102  if (desc->params[i].value.str && strcmp (desc->params[i].value.str, "") != 0) {
103  sprintf (arg_default, "%s", desc->params[i].value.str);
104  } else {
105  sprintf (arg_default, "none");
106  }
107  break;
108  case JackDriverParamBool:
109  sprintf (arg_default, "%s", desc->params[i].value.i ? "true" : "false");
110  break;
111  }
112 
113  fprintf(file, "\t-%c, --%s \t%s (default: %s)\n",
114  desc->params[i].character,
115  desc->params[i].name,
116  desc->params[i].long_desc,
117  arg_default);
118  }
119 }
120 
121 static void jack_print_driver_param_usage (jack_driver_desc_t* desc, unsigned long param, FILE *file)
122 {
123  fprintf (file, "Usage information for the '%s' parameter for driver '%s':\n",
124  desc->params[param].name, desc->name);
125  fprintf (file, "%s\n", desc->params[param].long_desc);
126 }
127 
128 void jack_free_driver_params(JSList * driver_params)
129 {
130  JSList*node_ptr = driver_params;
131  JSList*next_node_ptr;
132 
133  while (node_ptr) {
134  next_node_ptr = node_ptr->next;
135  free(node_ptr->data);
136  free(node_ptr);
137  node_ptr = next_node_ptr;
138  }
139 }
140 
141 int jack_parse_driver_params(jack_driver_desc_t* desc, int argc, char* argv[], JSList** param_ptr)
142 {
143  struct option * long_options;
144  char* options, * options_ptr;
145  unsigned long i;
146  int opt;
147  unsigned int param_index;
148  JSList* params = NULL;
149  jack_driver_param_t * driver_param;
150 
151  if (argc <= 1) {
152  *param_ptr = NULL;
153  return 0;
154  }
155 
156  /* check for help */
157  if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {
158  if (argc > 2) {
159  for (i = 0; i < desc->nparams; i++) {
160  if (strcmp (desc->params[i].name, argv[2]) == 0) {
161  jack_print_driver_param_usage (desc, i, stdout);
162  return 1;
163  }
164  }
165 
166  fprintf (stderr, "Jackd: unknown option '%s' "
167  "for driver '%s'\n", argv[2],
168  desc->name);
169  }
170 
171  jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);
172  jack_print_driver_options (desc, stdout);
173  return 1;
174  }
175 
176  /* set up the stuff for getopt */
177  options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));
178  long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));
179 
180  options_ptr = options;
181  for (i = 0; i < desc->nparams; i++) {
182  sprintf (options_ptr, "%c::", desc->params[i].character);
183  options_ptr += 3;
184  long_options[i].name = desc->params[i].name;
185  long_options[i].flag = NULL;
186  long_options[i].val = desc->params[i].character;
187  long_options[i].has_arg = optional_argument;
188  }
189 
190  /* create the params */
191  optind = 0;
192  opterr = 0;
193  while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {
194 
195  if (opt == ':' || opt == '?') {
196  if (opt == ':') {
197  fprintf (stderr, "Missing option to argument '%c'\n", optopt);
198  } else {
199  fprintf (stderr, "Unknownage with option '%c'\n", optopt);
200  }
201 
202  fprintf (stderr, "Options for driver '%s':\n", desc->name);
203  jack_print_driver_options (desc, stderr);
204  return 1;
205  }
206 
207  for (param_index = 0; param_index < desc->nparams; param_index++) {
208  if (opt == desc->params[param_index].character) {
209  break;
210  }
211  }
212 
213  driver_param = (jack_driver_param_t*)calloc (1, sizeof (jack_driver_param_t));
214  driver_param->character = desc->params[param_index].character;
215 
216  if (!optarg && optind < argc &&
217  strlen(argv[optind]) &&
218  argv[optind][0] != '-') {
219  optarg = argv[optind];
220  }
221 
222  if (optarg) {
223  switch (desc->params[param_index].type) {
224  case JackDriverParamInt:
225  driver_param->value.i = atoi(optarg);
226  break;
227  case JackDriverParamUInt:
228  driver_param->value.ui = strtoul(optarg, NULL, 10);
229  break;
230  case JackDriverParamChar:
231  driver_param->value.c = optarg[0];
232  break;
233  case JackDriverParamString:
234  strncpy (driver_param->value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);
235  break;
236  case JackDriverParamBool:
237  if (strcasecmp("false", optarg) == 0 ||
238  strcasecmp("off", optarg) == 0 ||
239  strcasecmp("no", optarg) == 0 ||
240  strcasecmp("0", optarg) == 0 ||
241  strcasecmp("(null)", optarg) == 0 ) {
242  driver_param->value.i = false;
243  } else {
244  driver_param->value.i = true;
245  }
246  break;
247  }
248  } else {
249  if (desc->params[param_index].type == JackDriverParamBool) {
250  driver_param->value.i = true;
251  } else {
252  driver_param->value = desc->params[param_index].value;
253  }
254  }
255 
256  params = jack_slist_append (params, driver_param);
257  }
258 
259  free (options);
260  free (long_options);
261 
262  if (param_ptr) {
263  *param_ptr = params;
264  }
265  return 0;
266 }
267 
268 SERVER_EXPORT int jackctl_driver_params_parse(jackctl_driver *driver_ptr, int argc, char* argv[])
269 {
270  struct option* long_options;
271  char* options, * options_ptr;
272  unsigned long i;
273  int opt;
274  JSList* node_ptr;
275  jackctl_parameter_t * param = NULL;
276  union jackctl_parameter_value value;
277 
278  if (argc <= 1) {
279  return 0;
280  }
281 
282  const JSList* driver_params = jackctl_driver_get_parameters(driver_ptr);
283  if (driver_params == NULL) {
284  return 1;
285  }
286 
287  jack_driver_desc_t* desc = jackctl_driver_get_desc(driver_ptr);
288 
289  /* check for help */
290  if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {
291  if (argc > 2) {
292  for (i = 0; i < desc->nparams; i++) {
293  if (strcmp (desc->params[i].name, argv[2]) == 0) {
294  jack_print_driver_param_usage (desc, i, stdout);
295  return 1;
296  }
297  }
298 
299  fprintf (stderr, "Jackd: unknown option '%s' "
300  "for driver '%s'\n", argv[2],
301  desc->name);
302  }
303 
304  jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);
305  jack_print_driver_options (desc, stdout);
306  return 1;
307  }
308 
309  /* set up the stuff for getopt */
310  options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));
311  long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));
312 
313  options_ptr = options;
314  for (i = 0; i < desc->nparams; i++) {
315  sprintf(options_ptr, "%c::", desc->params[i].character);
316  options_ptr += 3;
317  long_options[i].name = desc->params[i].name;
318  long_options[i].flag = NULL;
319  long_options[i].val = desc->params[i].character;
320  long_options[i].has_arg = optional_argument;
321  }
322 
323  /* create the params */
324  optind = 0;
325  opterr = 0;
326  while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {
327 
328  if (opt == ':' || opt == '?') {
329  if (opt == ':') {
330  fprintf (stderr, "Missing option to argument '%c'\n", optopt);
331  } else {
332  fprintf (stderr, "Unknownage with option '%c'\n", optopt);
333  }
334 
335  fprintf (stderr, "Options for driver '%s':\n", desc->name);
336  jack_print_driver_options(desc, stderr);
337  return 1;
338  }
339 
340  node_ptr = (JSList *)driver_params;
341  while (node_ptr) {
342  param = (jackctl_parameter_t*)node_ptr->data;
343  if (opt == jackctl_parameter_get_id(param)) {
344  break;
345  }
346  node_ptr = node_ptr->next;
347  }
348 
349  if (!optarg && optind < argc &&
350  strlen(argv[optind]) &&
351  argv[optind][0] != '-') {
352  optarg = argv[optind];
353  }
354 
355  if (optarg) {
356  switch (jackctl_parameter_get_type(param)) {
357  case JackDriverParamInt:
358  value.i = atoi(optarg);
359  jackctl_parameter_set_value(param, &value);
360  break;
361  case JackDriverParamUInt:
362  value.ui = strtoul(optarg, NULL, 10);
363  jackctl_parameter_set_value(param, &value);
364  break;
365  case JackDriverParamChar:
366  value.c = optarg[0];
367  jackctl_parameter_set_value(param, &value);
368  break;
369  case JackDriverParamString:
370  strncpy(value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);
371  jackctl_parameter_set_value(param, &value);
372  break;
373  case JackDriverParamBool:
374  if (strcasecmp("false", optarg) == 0 ||
375  strcasecmp("off", optarg) == 0 ||
376  strcasecmp("no", optarg) == 0 ||
377  strcasecmp("0", optarg) == 0 ||
378  strcasecmp("(null)", optarg) == 0 ) {
379  value.i = false;
380  } else {
381  value.i = true;
382  }
383  jackctl_parameter_set_value(param, &value);
384  break;
385  }
386  } else {
388  value.i = true;
389  } else {
391  }
392  jackctl_parameter_set_value(param, &value);
393  }
394  }
395 
396  free(options);
397  free(long_options);
398  return 0;
399 }
400 
401 jack_driver_desc_t* jack_find_driver_descriptor (JSList * drivers, const char* name)
402 {
403  jack_driver_desc_t* desc = 0;
404  JSList* node;
405 
406  for (node = drivers; node; node = jack_slist_next (node)) {
407  desc = (jack_driver_desc_t*) node->data;
408 
409  if (strcmp (desc->name, name) != 0) {
410  desc = NULL;
411  } else {
412  break;
413  }
414  }
415 
416  return desc;
417 }
418 
419 static void* check_symbol(const char* sofile, const char* symbol, const char* driver_dir, void** res_dllhandle = NULL)
420 {
421  void* dlhandle;
422  void* res = NULL;
423  char filename[1024];
424  sprintf(filename, "%s/%s", driver_dir, sofile);
425 
426  if ((dlhandle = LoadDriverModule(filename)) == NULL) {
427 #ifdef WIN32
428  jack_error ("Could not open component .dll '%s': %ld", filename, GetLastError());
429 #else
430  jack_error ("Could not open component .so '%s': %s", filename, dlerror());
431 #endif
432  } else {
433  res = (void*)GetDriverProc(dlhandle, symbol);
434  if (res_dllhandle) {
435  *res_dllhandle = dlhandle;
436  } else {
437  UnloadDriverModule(dlhandle);
438  }
439  }
440 
441  return res;
442 }
443 
444 static jack_driver_desc_t* jack_get_descriptor (JSList* drivers, const char* sofile, const char* symbol, const char* driver_dir)
445 {
446  jack_driver_desc_t* descriptor = NULL;
447  jack_driver_desc_t* other_descriptor;
448  JackDriverDescFunction so_get_descriptor = NULL;
449  char filename[1024];
450  JSList* node;
451  void* dlhandle;
452 
453  sprintf(filename, "%s/%s", driver_dir, sofile);
454  so_get_descriptor = (JackDriverDescFunction)check_symbol(sofile, symbol, driver_dir, &dlhandle);
455 
456  if (so_get_descriptor == NULL) {
457  jack_error("jack_get_descriptor : dll %s is not a driver", sofile);
458  goto error;
459  }
460 
461  if ((descriptor = so_get_descriptor ()) == NULL) {
462  jack_error("Driver from '%s' returned NULL descriptor", filename);
463  goto error;
464  }
465 
466  /* check it doesn't exist already */
467  for (node = drivers; node; node = jack_slist_next (node)) {
468  other_descriptor = (jack_driver_desc_t*) node->data;
469  if (strcmp(descriptor->name, other_descriptor->name) == 0) {
470  jack_error("The drivers in '%s' and '%s' both have the name '%s'; using the first",
471  other_descriptor->file, filename, other_descriptor->name);
472  /* FIXME: delete the descriptor */
473  goto error;
474  }
475  }
476 
477  strncpy(descriptor->file, filename, JACK_PATH_MAX);
478 
479 error:
480 
481  UnloadDriverModule(dlhandle);
482  return descriptor;
483 }
484 
485 #ifdef WIN32
486 
487 JSList * jack_drivers_load(JSList * drivers)
488 {
489  //char dll_filename[512];
490  WIN32_FIND_DATA filedata;
491  HANDLE file;
492  const char* ptr = NULL;
493  JSList* driver_list = NULL;
494  jack_driver_desc_t* desc = NULL;
495 
496  char* driver_dir = locate_driver_dir(file, filedata);
497  if (!driver_dir) {
498  jack_error("Driver folder not found");
499  goto error;
500  }
501 
502  do {
503  /* check the filename is of the right format */
504  if (strncmp ("jack_", filedata.cFileName, 5) != 0) {
505  continue;
506  }
507 
508  ptr = strrchr (filedata.cFileName, '.');
509  if (!ptr) {
510  continue;
511  }
512 
513  ptr++;
514  if (strncmp ("dll", ptr, 3) != 0) {
515  continue;
516  }
517 
518  /* check if dll is an internal client */
519  if (check_symbol(filedata.cFileName, "jack_internal_initialize", driver_dir) != NULL) {
520  continue;
521  }
522 
523  desc = jack_get_descriptor (drivers, filedata.cFileName, "driver_get_descriptor", driver_dir);
524  if (desc) {
525  driver_list = jack_slist_append (driver_list, desc);
526  } else {
527  jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);
528  }
529 
530  } while (FindNextFile(file, &filedata));
531 
532  if (!driver_list) {
533  jack_error ("Could not find any drivers in %s!", driver_dir);
534  }
535 
536 error:
537  if (driver_dir) {
538  free(driver_dir);
539  }
540  FindClose(file);
541  return driver_list;
542 }
543 
544 #else
545 
546 JSList* jack_drivers_load (JSList * drivers)
547 {
548  struct dirent * dir_entry;
549  DIR * dir_stream;
550  const char* ptr;
551  int err;
552  JSList* driver_list = NULL;
553  jack_driver_desc_t* desc = NULL;
554 
555  const char* driver_dir;
556  if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {
557  driver_dir = ADDON_DIR;
558  }
559 
560  /* search through the driver_dir and add get descriptors
561  from the .so files in it */
562  dir_stream = opendir (driver_dir);
563  if (!dir_stream) {
564  jack_error ("Could not open driver directory %s: %s",
565  driver_dir, strerror (errno));
566  return NULL;
567  }
568 
569  while ((dir_entry = readdir(dir_stream))) {
570 
571  /* check the filename is of the right format */
572  if (strncmp ("jack_", dir_entry->d_name, 5) != 0) {
573  continue;
574  }
575 
576  ptr = strrchr (dir_entry->d_name, '.');
577  if (!ptr) {
578  continue;
579  }
580  ptr++;
581  if (strncmp ("so", ptr, 2) != 0) {
582  continue;
583  }
584 
585  /* check if dll is an internal client */
586  if (check_symbol(dir_entry->d_name, "jack_internal_initialize", driver_dir) != NULL) {
587  continue;
588  }
589 
590  desc = jack_get_descriptor (drivers, dir_entry->d_name, "driver_get_descriptor", driver_dir);
591  if (desc) {
592  driver_list = jack_slist_append (driver_list, desc);
593  } else {
594  jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);
595  }
596  }
597 
598  err = closedir (dir_stream);
599  if (err) {
600  jack_error ("Error closing driver directory %s: %s",
601  driver_dir, strerror (errno));
602  }
603 
604  if (!driver_list) {
605  jack_error ("Could not find any drivers in %s!", driver_dir);
606  return NULL;
607  }
608 
609  return driver_list;
610 }
611 
612 #endif
613 
614 #ifdef WIN32
615 
616 JSList* jack_internals_load(JSList * internals)
617 {
619  WIN32_FIND_DATA filedata;
620  HANDLE file;
621  const char* ptr = NULL;
622  JSList* driver_list = NULL;
623  jack_driver_desc_t* desc;
624 
625  char* driver_dir = locate_driver_dir(file, filedata);
626  if (!driver_dir) {
627  jack_error("Driver folder not found");
628  goto error;
629  }
630 
631  do {
632 
633  ptr = strrchr (filedata.cFileName, '.');
634  if (!ptr) {
635  continue;
636  }
637 
638  ptr++;
639  if (strncmp ("dll", ptr, 3) != 0) {
640  continue;
641  }
642 
643  /* check if dll is an internal client */
644  if (check_symbol(filedata.cFileName, "jack_internal_initialize", driver_dir) == NULL) {
645  continue;
646  }
647 
648  desc = jack_get_descriptor (internals, filedata.cFileName, "jack_get_descriptor", driver_dir);
649  if (desc) {
650  driver_list = jack_slist_append (driver_list, desc);
651  } else {
652  jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);
653  }
654 
655  } while (FindNextFile(file, &filedata));
656 
657  if (!driver_list) {
658  jack_error ("Could not find any internals in %s!", driver_dir);
659  }
660 
661  error:
662  if (driver_dir) {
663  free(driver_dir);
664  }
665  FindClose(file);
666  return driver_list;
667 }
668 
669 #else
670 
671 JSList* jack_internals_load(JSList * internals)
672 {
673  struct dirent * dir_entry;
674  DIR * dir_stream;
675  const char* ptr;
676  int err;
677  JSList* driver_list = NULL;
678  jack_driver_desc_t* desc;
679 
680  const char* driver_dir;
681  if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {
682  driver_dir = ADDON_DIR;
683  }
684 
685  /* search through the driver_dir and add get descriptors
686  from the .so files in it */
687  dir_stream = opendir (driver_dir);
688  if (!dir_stream) {
689  jack_error ("Could not open driver directory %s: %s\n",
690  driver_dir, strerror (errno));
691  return NULL;
692  }
693 
694  while ((dir_entry = readdir(dir_stream))) {
695 
696  ptr = strrchr (dir_entry->d_name, '.');
697  if (!ptr) {
698  continue;
699  }
700 
701  ptr++;
702  if (strncmp ("so", ptr, 2) != 0) {
703  continue;
704  }
705 
706  /* check if dll is an internal client */
707  if (check_symbol(dir_entry->d_name, "jack_internal_initialize", driver_dir) == NULL) {
708  continue;
709  }
710 
711  desc = jack_get_descriptor (internals, dir_entry->d_name, "jack_get_descriptor", driver_dir);
712  if (desc) {
713  driver_list = jack_slist_append (driver_list, desc);
714  } else {
715  jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);
716  }
717  }
718 
719  err = closedir (dir_stream);
720  if (err) {
721  jack_error ("Error closing internal directory %s: %s\n",
722  driver_dir, strerror (errno));
723  }
724 
725  if (!driver_list) {
726  jack_error ("Could not find any internals in %s!", driver_dir);
727  return NULL;
728  }
729 
730  return driver_list;
731 }
732 
733 #endif
734 
735 Jack::JackDriverClientInterface* JackDriverInfo::Open(jack_driver_desc_t* driver_desc,
736  Jack::JackLockedEngine* engine,
737  Jack::JackSynchro* synchro,
738  const JSList* params)
739 {
740 #ifdef WIN32
741  int errstr;
742 #else
743  const char* errstr;
744 #endif
745 
746  fHandle = LoadDriverModule (driver_desc->file);
747 
748  if (fHandle == NULL) {
749 #ifdef WIN32
750  if ((errstr = GetLastError ()) != 0) {
751  jack_error ("Can't load \"%s\": %ld", driver_desc->file, errstr);
752 #else
753  if ((errstr = dlerror ()) != 0) {
754  jack_error ("Can't load \"%s\": %s", driver_desc->file, errstr);
755 #endif
756 
757  } else {
758  jack_error ("Error loading driver shared object %s", driver_desc->file);
759  }
760  return NULL;
761  }
762 
763  fInitialize = (driverInitialize)GetDriverProc(fHandle, "driver_initialize");
764 
765 #ifdef WIN32
766  if ((fInitialize == NULL) && (errstr = GetLastError ()) != 0) {
767 #else
768  if ((fInitialize == NULL) && (errstr = dlerror ()) != 0) {
769 #endif
770  jack_error("No initialize function in shared object %s\n", driver_desc->file);
771  return NULL;
772  }
773 
774  fBackend = fInitialize(engine, synchro, params);
775  return fBackend;
776 }
777 
778 JackDriverInfo::~JackDriverInfo()
779 {
780  delete fBackend;
781  if (fHandle) {
782  UnloadDriverModule(fHandle);
783  }
784 }
785 
786 SERVER_EXPORT jack_driver_desc_t* jack_driver_descriptor_construct(
787  const char * name,
788  jack_driver_type_t type,
789  const char * description,
790  jack_driver_desc_filler_t * filler_ptr)
791 {
792  size_t name_len;
793  size_t description_len;
794  jack_driver_desc_t* desc_ptr;
795 
796  name_len = strlen(name);
797  description_len = strlen(description);
798 
799  if (name_len > sizeof(desc_ptr->name) - 1 ||
800  description_len > sizeof(desc_ptr->desc) - 1) {
801  assert(false);
802  return 0;
803  }
804 
805  desc_ptr = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));
806  if (desc_ptr == NULL) {
807  jack_error("Error calloc() failed to allocate memory for driver descriptor struct");
808  return 0;
809  }
810 
811  memcpy(desc_ptr->name, name, name_len + 1);
812  memcpy(desc_ptr->desc, description, description_len + 1);
813 
814  desc_ptr->nparams = 0;
815  desc_ptr->type = type;
816 
817  if (filler_ptr != NULL) {
818  filler_ptr->size = 0;
819  }
820 
821  return desc_ptr;
822 }
823 
824 SERVER_EXPORT int jack_driver_descriptor_add_parameter(
825  jack_driver_desc_t* desc_ptr,
826  jack_driver_desc_filler_t * filler_ptr,
827  const char* name,
828  char character,
829  jack_driver_param_type_t type,
830  const jack_driver_param_value_t * value_ptr,
832  const char* short_desc,
833  const char* long_desc)
834 {
835  size_t name_len;
836  size_t short_desc_len;
837  size_t long_desc_len;
838  jack_driver_param_desc_t * param_ptr;
839  size_t newsize;
840 
841  name_len = strlen(name);
842  short_desc_len = strlen(short_desc);
843 
844  if (long_desc != NULL) {
845  long_desc_len = strlen(long_desc);
846  } else {
847  long_desc = short_desc;
848  long_desc_len = short_desc_len;
849  }
850 
851  if (name_len > sizeof(param_ptr->name) - 1 ||
852  short_desc_len > sizeof(param_ptr->short_desc) - 1 ||
853  long_desc_len > sizeof(param_ptr->long_desc) - 1) {
854  assert(false);
855  return 0;
856  }
857 
858  if (desc_ptr->nparams == filler_ptr->size) {
859  newsize = filler_ptr->size + 20; // most drivers have less than 20 parameters
860  param_ptr = (jack_driver_param_desc_t*)realloc (desc_ptr->params, newsize * sizeof (jack_driver_param_desc_t));
861  if (param_ptr == NULL) {
862  jack_error("Error realloc() failed for parameter array of %zu elements", newsize);
863  return false;
864  }
865  filler_ptr->size = newsize;
866  desc_ptr->params = param_ptr;
867  }
868 
869  assert(desc_ptr->nparams < filler_ptr->size);
870  param_ptr = desc_ptr->params + desc_ptr->nparams;
871 
872  memcpy(param_ptr->name, name, name_len + 1);
873  param_ptr->character = character;
874  param_ptr->type = type;
875  param_ptr->value = *value_ptr;
876  param_ptr->constraint = constraint;
877  memcpy(param_ptr->short_desc, short_desc, short_desc_len + 1);
878  memcpy(param_ptr->long_desc, long_desc, long_desc_len + 1);
879 
880  desc_ptr->nparams++;
881  return true;
882 }
SERVER_EXPORT int jackctl_driver_params_parse(jackctl_driver *driver_ptr, int argc, char *argv[])
Inter process synchronization using using Mach semaphore.
Locked Engine, access to methods is serialized using a mutex.
char str[JACK_PARAM_STRING_MAX+1]
member used for JackParamString
SERVER_EXPORT union jackctl_parameter_value jackctl_parameter_get_default_value(jackctl_parameter *parameter_ptr)
char file[JACK_PATH_MAX+1]
SERVER_EXPORT void jack_error(const char *fmt,...)
Definition: JackError.cpp:91
uint32_t ui
member used for JackParamUInt
jack_driver_type_t type
jack_driver_param_value_t value
SERVER_EXPORT void jack_info(const char *fmt,...)
Definition: JackError.cpp:99
value type is a boolean
Definition: control.h:46
int32_t i
member used for JackParamInt
Definition: getopt.h:84
Type for parameter value.
SERVER_EXPORT const JSList * jackctl_driver_get_parameters(jackctl_driver *driver_ptr)
jack_driver_param_constraint_desc_t * constraint
SERVER_EXPORT jackctl_param_type_t jackctl_parameter_get_type(jackctl_parameter *parameter_ptr)
char name[JACK_DRIVER_NAME_MAX+1]
char name[JACK_DRIVER_NAME_MAX+1]
SERVER_EXPORT bool jackctl_parameter_set_value(jackctl_parameter *parameter_ptr, const union jackctl_parameter_value *value_ptr)
The base interface for drivers clients.
Definition: JackDriver.h:122
char desc[JACK_DRIVER_PARAM_DESC+1]
jack_driver_param_type_t type
SERVER_EXPORT char jackctl_parameter_get_id(jackctl_parameter_t *parameter_ptr)
char c
member used for JackParamChar
SERVER_EXPORT void jack_log(const char *fmt,...)
Definition: JackError.cpp:107
jack_driver_param_desc_t * params