jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4048 Commits
6 Branches
50MB
Tree: 99e5d115ea
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '99e5d115ea'
${ noResults }
jack2/common/JackDriverLoader.cpp

1031 lines
31KB
Raw Blame History 

  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. typedef wchar_t file_char_t;

  37. #else

  38. typedef char file_char_t;

  39. #endif

  40. 

  41. #ifdef WIN32

  42. 

  43. static wchar_t* locate_dll_driver_dir()

  44. {

  45.     HMODULE libjack_handle = NULL;

  46.     GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,

  47.                        reinterpret_cast<LPCWSTR>(locate_dll_driver_dir), &libjack_handle);

  48. 

  49.     // For WIN32 ADDON_DIR is defined in JackConstants.h as relative path

  50.     wchar_t driver_dir_storage[512];

  51.     if (3 < GetModuleFileNameW(libjack_handle, driver_dir_storage, 512)) {

  52.         wchar_t *p = wcsrchr(driver_dir_storage, L'\\');

  53.         if (p && (p != driver_dir_storage)) {

  54.             *p = 0;

  55.         }   

  56.         jack_info("Drivers/internals found in : %S", driver_dir_storage);

  57.         wcscat(driver_dir_storage, L"\\");

  58.         wcscat(driver_dir_storage, ADDON_DIRW);

  59.         return wcsdup(driver_dir_storage);

  60.     } else {

  61.         jack_error("Cannot get JACK dll directory : %d", GetLastError());

  62.         return NULL;

  63.     }

  64. }

  65. 

  66. static wchar_t* locate_driver_dir(HANDLE& file, WIN32_FIND_DATAW& filedata)

  67. {

  68.     // Search drivers/internals iin the same folder of "libjackserver.dll"

  69.     wchar_t* driver_dir = locate_dll_driver_dir();

  70.     wchar_t dll_filename[512];

  71.     swprintf(dll_filename, 510, L"%S/*.dll", driver_dir);

  72.     file = (HANDLE)FindFirstFileW(dll_filename, &filedata);

  73. 

  74.     if (file == INVALID_HANDLE_VALUE) {

  75.         jack_error("Drivers not found in \"%S\": \"%S\"", driver_dir, dll_filename);

  76.         free(driver_dir);

  77.         return NULL;

  78.     } else {

  79.         return driver_dir;

  80.     }

  81. }

  82. 

  83. #endif

  84. 

  85. jack_driver_desc_t* jackctl_driver_get_desc(jackctl_driver_t * driver);

  86. 

  87. void jack_print_driver_options(jack_driver_desc_t* desc, FILE* file)

  88. {

  89.     unsigned long i;

  90.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  91. 

  92.     for (i = 0; i < desc->nparams; i++) {

  93.         switch (desc->params[i].type) {

  94.             case JackDriverParamInt:

  95.                 sprintf (arg_default, "%" "i", desc->params[i].value.i);

  96.                 break;

  97.             case JackDriverParamUInt:

  98.                 sprintf (arg_default, "%" "u", desc->params[i].value.ui);

  99.                 break;

  100.             case JackDriverParamChar:

  101.                 sprintf (arg_default, "%c", desc->params[i].value.c);

  102.                 break;

  103.             case JackDriverParamString:

  104.                 if (desc->params[i].value.str && strcmp (desc->params[i].value.str, "") != 0) {

  105.                     sprintf (arg_default, "%s", desc->params[i].value.str);

  106.                 } else {

  107.                     sprintf (arg_default, "none");

  108.                 }

  109.                 break;

  110.             case JackDriverParamBool:

  111.                 sprintf (arg_default, "%s", desc->params[i].value.i ? "true" : "false");

  112.                 break;

  113.         }

  114. 

  115.         fprintf(file, "\t-%c, --%s \t%s (default: %s)\n",

  116.                  desc->params[i].character,

  117.                  desc->params[i].name,

  118.                  desc->params[i].long_desc,

  119.                  arg_default);

  120.     }

  121. }

  122. 

  123. static void jack_print_driver_param_usage (jack_driver_desc_t* desc, unsigned long param, FILE *file)

  124. {

  125.     fprintf (file, "Usage information for the '%s' parameter for driver '%s':\n",

  126.              desc->params[param].name, desc->name);

  127.     fprintf (file, "%s\n", desc->params[param].long_desc);

  128. }

  129. 

  130. void jack_free_driver_params(JSList * driver_params)

  131. {

  132.     JSList*node_ptr = driver_params;

  133.     JSList*next_node_ptr;

  134. 

  135.     while (node_ptr) {

  136.         next_node_ptr = node_ptr->next;

  137.         free(node_ptr->data);

  138.         free(node_ptr);

  139.         node_ptr = next_node_ptr;

  140.     }

  141. }

  142. 

  143. int jack_parse_driver_params(jack_driver_desc_t* desc, int argc, char* argv[], JSList** param_ptr)

  144. {

  145.     struct option * long_options;

  146.     char* options, * options_ptr;

  147.     unsigned long i;

  148.     int opt;

  149.     unsigned int param_index;

  150.     JSList* params = NULL;

  151.     jack_driver_param_t * driver_param;

  152. 

  153.     if (argc <= 1) {

  154.         *param_ptr = NULL;

  155.         return 0;

  156.     }

  157. 

  158.     /* check for help */

  159.     if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {

  160.         if (argc > 2) {

  161.             for (i = 0; i < desc->nparams; i++) {

  162.                 if (strcmp (desc->params[i].name, argv[2]) == 0) {

  163.                     jack_print_driver_param_usage (desc, i, stdout);

  164.                     return 1;

  165.                 }

  166.             }

  167. 

  168.             fprintf (stderr, "Jackd: unknown option '%s' "

  169.                      "for driver '%s'\n", argv[2],

  170.                      desc->name);

  171.         }

  172. 

  173.         jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);

  174.         jack_print_driver_options (desc, stdout);

  175.         return 1;

  176.     }

  177. 

  178.     /* set up the stuff for getopt */

  179.     options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));

  180.     long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));

  181. 

  182.     options_ptr = options;

  183.     for (i = 0; i < desc->nparams; i++) {

  184.         sprintf (options_ptr, "%c::", desc->params[i].character);

  185.         options_ptr += 3;

  186.         long_options[i].name = desc->params[i].name;

  187.         long_options[i].flag = NULL;

  188.         long_options[i].val = desc->params[i].character;

  189.         long_options[i].has_arg = optional_argument;

  190.     }

  191. 

  192.     /* create the params */

  193.     optind = 0;

  194.     opterr = 0;

  195.     while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {

  196. 

  197.         if (opt == ':' || opt == '?') {

  198.             if (opt == ':') {

  199.                 fprintf (stderr, "Missing option to argument '%c'\n", optopt);

  200.             } else {

  201.                 fprintf (stderr, "Unknownage with option '%c'\n", optopt);

  202.             }

  203. 

  204.             fprintf (stderr, "Options for driver '%s':\n", desc->name);

  205.             jack_print_driver_options (desc, stderr);

  206.             return 1;

  207.         }

  208. 

  209.         for (param_index = 0; param_index < desc->nparams; param_index++) {

  210.             if (opt == desc->params[param_index].character) {

  211.                 break;

  212.             }

  213.         }

  214. 

  215.         driver_param = (jack_driver_param_t*)calloc (1, sizeof (jack_driver_param_t));

  216.         driver_param->character = desc->params[param_index].character;

  217. 

  218.         if (!optarg && optind < argc &&

  219.                 strlen(argv[optind]) &&

  220.                 argv[optind][0] != '-') {

  221.             optarg = argv[optind];

  222.         }

  223. 

  224.         if (optarg) {

  225.             switch (desc->params[param_index].type) {

  226.                 case JackDriverParamInt:

  227.                     driver_param->value.i = atoi(optarg);

  228.                     break;

  229.                 case JackDriverParamUInt:

  230.                     driver_param->value.ui = strtoul(optarg, NULL, 10);

  231.                     break;

  232.                 case JackDriverParamChar:

  233.                     driver_param->value.c = optarg[0];

  234.                     break;

  235.                 case JackDriverParamString:

  236.                     strncpy (driver_param->value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);

  237.                     break;

  238.                 case JackDriverParamBool:

  239.                     if (strcasecmp("false", optarg) == 0 ||

  240.                         strcasecmp("off", optarg) == 0 ||

  241.                         strcasecmp("no", optarg) == 0 ||

  242.                         strcasecmp("0", optarg) == 0 ||

  243.                         strcasecmp("(null)", optarg) == 0 ) {

  244.                         driver_param->value.i = false;

  245.                     } else {

  246.                         driver_param->value.i = true;

  247.                     }

  248.                     break;

  249.             }

  250.         } else {

  251.             if (desc->params[param_index].type == JackDriverParamBool) {

  252.                 driver_param->value.i = true;

  253.             } else {

  254.                 driver_param->value = desc->params[param_index].value;

  255.             }

  256.         }

  257. 

  258.         params = jack_slist_append (params, driver_param);

  259.     }

  260. 

  261.     free (options);

  262.     free (long_options);

  263. 

  264.     if (param_ptr) {

  265.         *param_ptr = params;

  266.     }

  267.     return 0;

  268. }

  269. 

  270. SERVER_EXPORT int jackctl_driver_params_parse(jackctl_driver *driver_ptr, int argc, char* argv[])

  271. {

  272.     struct option* long_options;

  273.     char* options, * options_ptr;

  274.     unsigned long i;

  275.     int opt;

  276.     JSList* node_ptr;

  277.     jackctl_parameter_t * param = NULL;

  278.     union jackctl_parameter_value value;

  279. 

  280.     if (argc <= 1) {

  281.         return 0;

  282.     }

  283. 

  284.     const JSList* driver_params = jackctl_driver_get_parameters(driver_ptr);

  285.     if (driver_params == NULL) {

  286.         return 1;

  287.     }

  288. 

  289.     jack_driver_desc_t* desc = jackctl_driver_get_desc(driver_ptr);

  290. 

  291.     /* check for help */

  292.     if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {

  293.         if (argc > 2) {

  294.             for (i = 0; i < desc->nparams; i++) {

  295.                 if (strcmp (desc->params[i].name, argv[2]) == 0) {

  296.                     jack_print_driver_param_usage (desc, i, stdout);

  297.                     return 1;

  298.                 }

  299.             }

  300. 

  301.             fprintf (stderr, "Jackd: unknown option '%s' "

  302.                      "for driver '%s'\n", argv[2],

  303.                      desc->name);

  304.         }

  305. 

  306.         jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);

  307.         jack_print_driver_options (desc, stdout);

  308.         return 1;

  309.     }

  310. 

  311.    /* set up the stuff for getopt */

  312.     options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));

  313.     long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));

  314. 

  315.     options_ptr = options;

  316.     for (i = 0; i < desc->nparams; i++) {

  317.         sprintf(options_ptr, "%c::", desc->params[i].character);

  318.         options_ptr += 3;

  319.         long_options[i].name = desc->params[i].name;

  320.         long_options[i].flag = NULL;

  321.         long_options[i].val = desc->params[i].character;

  322.         long_options[i].has_arg = optional_argument;

  323.     }

  324. 

  325.     /* create the params */

  326.     optind = 0;

  327.     opterr = 0;

  328.     while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {

  329. 

  330.         if (opt == ':' || opt == '?') {

  331.             if (opt == ':') {

  332.                 fprintf (stderr, "Missing option to argument '%c'\n", optopt);

  333.             } else {

  334.                 fprintf (stderr, "Unknownage with option '%c'\n", optopt);

  335.             }

  336. 

  337.             fprintf (stderr, "Options for driver '%s':\n", desc->name);

  338.             jack_print_driver_options(desc, stderr);

  339.             return 1;

  340.         }

  341. 

  342.         node_ptr = (JSList *)driver_params;

  343.        	while (node_ptr) {

  344.             param = (jackctl_parameter_t*)node_ptr->data;

  345.             if (opt == jackctl_parameter_get_id(param)) {

  346.                 break;

  347.             }

  348.             node_ptr = node_ptr->next;

  349.         }

  350. 

  351.         if (!optarg && optind < argc &&

  352.             strlen(argv[optind]) &&

  353.             argv[optind][0] != '-') {

  354.             optarg = argv[optind];

  355.         }

  356. 

  357.         if (optarg) {

  358.             switch (jackctl_parameter_get_type(param)) {

  359.                 case JackDriverParamInt:

  360.                     value.i = atoi(optarg);

  361.                     jackctl_parameter_set_value(param, &value);

  362.                     break;

  363.                 case JackDriverParamUInt:

  364.                     value.ui = strtoul(optarg, NULL, 10);

  365.                     jackctl_parameter_set_value(param, &value);

  366.                     break;

  367.                 case JackDriverParamChar:

  368.                     value.c = optarg[0];

  369.                     jackctl_parameter_set_value(param, &value);

  370.                     break;

  371.                 case JackDriverParamString:

  372.                     strncpy(value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);

  373.                     jackctl_parameter_set_value(param, &value);

  374.                     break;

  375.                 case JackDriverParamBool:

  376.                     if (strcasecmp("false", optarg) == 0 ||

  377.                         strcasecmp("off", optarg) == 0 ||

  378.                         strcasecmp("no", optarg) == 0 ||

  379.                         strcasecmp("0", optarg) == 0 ||

  380.                         strcasecmp("(null)", optarg) == 0 ) {

  381.                         value.i = false;

  382.                     } else {

  383.                         value.i = true;

  384.                     }

  385.                     jackctl_parameter_set_value(param, &value);

  386.                     break;

  387.             }

  388.         } else {

  389.             if (jackctl_parameter_get_type(param) == JackParamBool) {

  390.                 value.i = true;

  391.             } else {

  392.                 value = jackctl_parameter_get_default_value(param);

  393.             }

  394.             jackctl_parameter_set_value(param, &value);

  395.         }

  396.     }

  397. 

  398.     free(options);

  399.     free(long_options);

  400.     return 0;

  401. }

  402. 

  403. jack_driver_desc_t* jack_find_driver_descriptor (JSList * drivers, const char* name)

  404. {

  405.     jack_driver_desc_t* desc = 0;

  406.     JSList* node;

  407. 

  408.     for (node = drivers; node; node = jack_slist_next (node)) {

  409.         desc = (jack_driver_desc_t*) node->data;

  410. 

  411.         if (strcmp (desc->name, name) != 0) {

  412.             desc = NULL;

  413.         } else {

  414.             break;

  415.         }

  416.     }

  417. 

  418.     return desc;

  419. }

  420. 

  421. static void* check_symbol(const file_char_t* sofile, const char* symbol, const file_char_t* driver_dir, void** res_dllhandle = NULL)

  422. {

  423.     void* dlhandle;

  424.     void* res = NULL;

  425.     file_char_t filename[1024];

  426. #ifdef WIN32

  427.     swprintf(filename, 1022, L"%S/%S", driver_dir, sofile);

  428. #else

  429.     snprintf(filename, 1022, "%s/%s", driver_dir, sofile);

  430. #endif

  431.     

  432.     if ((dlhandle = LoadDriverModule(filename)) == NULL) {

  433. #ifdef WIN32

  434.         jack_error ("Could not open component .dll '%S': %ld", filename, GetLastError());

  435. #else

  436.         jack_error ("Could not open component .so '%s': %s", filename, dlerror());

  437. #endif

  438.     } else {

  439.         res = (void*)GetDriverProc(dlhandle, symbol);

  440.         if (res_dllhandle) {

  441.             *res_dllhandle = dlhandle;

  442.         } else {

  443.             UnloadDriverModule(dlhandle);

  444.         }

  445.     }

  446. 

  447.     return res;

  448. }

  449. 

  450. static jack_driver_desc_t* jack_get_descriptor (JSList* drivers, const file_char_t* sofile, const char* symbol, const file_char_t* driver_dir)

  451. {

  452.     jack_driver_desc_t* descriptor = NULL;

  453.     jack_driver_desc_t* other_descriptor;

  454.     JackDriverDescFunction so_get_descriptor = NULL;

  455.     file_char_t filename[1024];

  456.     JSList* node;

  457.     void* dlhandle = NULL;

  458. 

  459. #ifdef WIN32

  460.     swprintf(filename, 1022, L"%S/%S", driver_dir, sofile);

  461. #else

  462.     snprintf(filename, 1022, "%s/%s", driver_dir, sofile);

  463. #endif

  464.     

  465.     so_get_descriptor = (JackDriverDescFunction)check_symbol(sofile, symbol, driver_dir, &dlhandle);

  466. 

  467.     if (so_get_descriptor == NULL) {

  468.         jack_error("jack_get_descriptor : dll %S is not a driver", sofile);

  469.         goto error;

  470.     }

  471. 

  472.     if ((descriptor = so_get_descriptor ()) == NULL) {

  473.         jack_error("Driver from '%S' returned NULL descriptor", filename);

  474.         goto error;

  475.     }

  476. 

  477.     /* check it doesn't exist already */

  478.     for (node = drivers; node; node = jack_slist_next (node)) {

  479.         other_descriptor = (jack_driver_desc_t*) node->data;

  480.         if (strcmp(descriptor->name, other_descriptor->name) == 0) {

  481.             jack_error("The drivers in '%S' and '%S' both have the name '%S'; using the first",

  482.                        other_descriptor->file, filename, other_descriptor->name);

  483.             /* FIXME: delete the descriptor */

  484.             goto error;

  485.         }

  486.     }

  487. 

  488. #ifdef WIN32

  489.     wcsncpy(descriptor->file, filename, JACK_PATH_MAX);

  490. #else

  491.     strncpy(descriptor->file, filename, JACK_PATH_MAX);

  492. #endif

  493.     

  494. error:

  495.     if (dlhandle) {

  496.         UnloadDriverModule(dlhandle);

  497.     }

  498.     return descriptor;

  499. }

  500. 

  501. #ifdef WIN32

  502. 

  503. JSList * jack_drivers_load(JSList * drivers)

  504. {

  505.     //char dll_filename[512];

  506.     WIN32_FIND_DATAW filedata;

  507.     HANDLE file;

  508.     const wchar_t* ptr = NULL;

  509.     JSList* driver_list = NULL;

  510.     jack_driver_desc_t* desc = NULL;

  511. 

  512.     wchar_t* driver_dir = locate_driver_dir(file, filedata);

  513.     if (!driver_dir) {

  514.         jack_error("Driver folder not found");

  515.         goto error;

  516.     }

  517. 

  518.     do {

  519.         /* check the filename is of the right format */

  520.         if (wcsncmp (L"jack_", filedata.cFileName, 5) != 0) {

  521.             continue;

  522.         }

  523. 

  524.         ptr = wcsrchr (filedata.cFileName, L'.');

  525.         if (!ptr) {

  526.             continue;

  527.         }

  528. 

  529.         ptr++;

  530.         if (wcsncmp (L"dll", ptr, 3) != 0) {

  531.             continue;

  532.         }

  533. 

  534.         /* check if dll is an internal client */

  535.         if (check_symbol(filedata.cFileName, "jack_internal_initialize", driver_dir) != NULL) {

  536.             continue;

  537.         }

  538. 

  539.         desc = jack_get_descriptor (drivers, filedata.cFileName, "driver_get_descriptor", driver_dir);

  540.         if (desc) {

  541.             driver_list = jack_slist_append (driver_list, desc);

  542.         } else {

  543.             jack_error ("jack_get_descriptor returns null for \'%S\'", filedata.cFileName);

  544.         }

  545. 

  546.     } while (FindNextFileW(file, &filedata));

  547. 

  548.     if (!driver_list) {

  549.         jack_error ("Could not find any drivers in %S!", driver_dir);

  550.     }

  551. 

  552. error:

  553.     if (driver_dir) {

  554.         free(driver_dir);

  555.     }

  556.     FindClose(file);

  557.     return driver_list;

  558. }

  559. 

  560. #else

  561. 

  562. JSList* jack_drivers_load (JSList * drivers)

  563. {

  564.     struct dirent * dir_entry;

  565.     DIR * dir_stream;

  566.     const char* ptr;

  567.     int err;

  568.     JSList* driver_list = NULL;

  569.     jack_driver_desc_t* desc = NULL;

  570. 

  571.     const char* driver_dir;

  572.     if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {

  573.         driver_dir = ADDON_DIR;

  574.     }

  575. 

  576.     /* search through the driver_dir and add get descriptors

  577.     from the .so files in it */

  578.     dir_stream = opendir (driver_dir);

  579.     if (!dir_stream) {

  580.         jack_error ("Could not open driver directory %s: %s",

  581.                     driver_dir, strerror (errno));

  582.         return NULL;

  583.     }

  584. 

  585.     while ((dir_entry = readdir(dir_stream))) {

  586. 

  587.         /* check the filename is of the right format */

  588.         if (strncmp ("jack_", dir_entry->d_name, 5) != 0) {

  589.             continue;

  590.         }

  591. 

  592.         ptr = strrchr (dir_entry->d_name, '.');

  593.         if (!ptr) {

  594.             continue;

  595.         }

  596.         ptr++;

  597.         if (strncmp ("so", ptr, 2) != 0) {

  598.             continue;

  599.         }

  600. 

  601.         /* check if dll is an internal client */

  602.         if (check_symbol(dir_entry->d_name, "jack_internal_initialize", driver_dir) != NULL) {

  603.             continue;

  604.         }

  605. 

  606.         desc = jack_get_descriptor (drivers, dir_entry->d_name, "driver_get_descriptor", driver_dir);

  607.         if (desc) {

  608.             driver_list = jack_slist_append (driver_list, desc);

  609.         } else {

  610.             jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);

  611.         }

  612.     }

  613. 

  614.     err = closedir (dir_stream);

  615.     if (err) {

  616.         jack_error ("Error closing driver directory %s: %s",

  617.                     driver_dir, strerror (errno));

  618.     }

  619. 

  620.     if (!driver_list) {

  621.         jack_error ("Could not find any drivers in %s!", driver_dir);

  622.         return NULL;

  623.     }

  624. 

  625.     return driver_list;

  626. }

  627. 

  628. #endif

  629. 

  630. #ifdef WIN32

  631. 

  632. JSList* jack_internals_load(JSList * internals)

  633. {

  634.     ///char dll_filename[512];

  635.     WIN32_FIND_DATAW filedata;

  636.     HANDLE file;

  637.     const wchar_t* ptr = NULL;

  638.     JSList* driver_list = NULL;

  639.     jack_driver_desc_t* desc;

  640. 

  641.     wchar_t* driver_dir = locate_driver_dir(file, filedata);

  642.     if (!driver_dir) {

  643.         jack_error("Driver folder not found");

  644.         goto error;

  645.     }

  646. 

  647.     do {

  648. 

  649.         ptr = wcsrchr (filedata.cFileName, L'.');

  650.         if (!ptr) {

  651.             continue;

  652.         }

  653. 

  654.         ptr++;

  655.         if (wcsncmp (L"dll", ptr, 3) != 0) {

  656.             continue;

  657.         }

  658. 

  659.         /* check if dll is an internal client */

  660.         if (check_symbol(filedata.cFileName, "jack_internal_initialize", driver_dir) == NULL) {

  661.             continue;

  662.         }

  663. 

  664.         desc = jack_get_descriptor (internals, filedata.cFileName, "jack_get_descriptor", driver_dir);

  665.         if (desc) {

  666.             driver_list = jack_slist_append (driver_list, desc);

  667.         } else {

  668.             jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);

  669.         }

  670. 

  671.     } while (FindNextFileW(file, &filedata));

  672. 

  673.     if (!driver_list) {

  674.         jack_error ("Could not find any internals in %s!", driver_dir);

  675.     }

  676. 

  677.  error:

  678.     if (driver_dir) {

  679.         free(driver_dir);

  680.     }

  681.     FindClose(file);

  682.     return driver_list;

  683. }

  684. 

  685. #else

  686. 

  687. JSList* jack_internals_load(JSList * internals)

  688. {

  689.     struct dirent * dir_entry;

  690.     DIR * dir_stream;

  691.     const char* ptr;

  692.     int err;

  693.     JSList* driver_list = NULL;

  694.     jack_driver_desc_t* desc;

  695. 

  696.     const char* driver_dir;

  697.     if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {

  698.         driver_dir = ADDON_DIR;

  699.     }

  700. 

  701.     /* search through the driver_dir and add get descriptors

  702.     from the .so files in it */

  703.     dir_stream = opendir (driver_dir);

  704.     if (!dir_stream) {

  705.         jack_error ("Could not open driver directory %s: %s\n",

  706.                     driver_dir, strerror (errno));

  707.         return NULL;

  708.     }

  709. 

  710.     while ((dir_entry = readdir(dir_stream))) {

  711. 

  712.         ptr = strrchr (dir_entry->d_name, '.');

  713.         if (!ptr) {

  714.             continue;

  715.         }

  716. 

  717.         ptr++;

  718.         if (strncmp ("so", ptr, 2) != 0) {

  719.             continue;

  720.         }

  721. 

  722.         /* check if dll is an internal client */

  723.         if (check_symbol(dir_entry->d_name, "jack_internal_initialize", driver_dir) == NULL) {

  724.             continue;

  725.         }

  726. 

  727.         desc = jack_get_descriptor (internals, dir_entry->d_name, "jack_get_descriptor", driver_dir);

  728.         if (desc) {

  729.             driver_list = jack_slist_append (driver_list, desc);

  730.         } else {

  731.             jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);

  732.         }

  733.     }

  734. 

  735.     err = closedir (dir_stream);

  736.     if (err) {

  737.         jack_error ("Error closing internal directory %s: %s\n",

  738.                     driver_dir, strerror (errno));

  739.     }

  740. 

  741.     if (!driver_list) {

  742.         jack_error ("Could not find any internals in %s!", driver_dir);

  743.         return NULL;

  744.     }

  745. 

  746.     return driver_list;

  747. }

  748. 

  749. #endif

  750. 

  751. Jack::JackDriverClientInterface* JackDriverInfo::Open(jack_driver_desc_t* driver_desc,

  752.                                                     Jack::JackLockedEngine* engine,

  753.                                                     Jack::JackSynchro* synchro,

  754.                                                     const JSList* params)

  755. {

  756. #ifdef WIN32

  757.     int errstr;

  758. #else

  759.     const char* errstr;

  760. #endif

  761. 

  762.     fHandle = LoadDriverModule (driver_desc->file);

  763. 

  764.     if (fHandle == NULL) {

  765. #ifdef WIN32

  766.         if ((errstr = GetLastError ()) != 0) {

  767.             jack_error ("Can't load \"%S\": %ld", driver_desc->file, errstr);

  768. #else

  769.         if ((errstr = dlerror ()) != 0) {

  770.             jack_error ("Can't load \"%s\": %s", driver_desc->file, errstr);

  771. #endif

  772. 

  773.         } else {

  774. #ifdef WIN32

  775.           jack_error ("Error loading driver shared object %S", driver_desc->file);

  776. #else

  777.           jack_error ("Error loading driver shared object %s", driver_desc->file);

  778. #endif

  779.         }

  780.         return NULL;

  781.     }

  782. 

  783. 

  784.     //jack_error (" ---------------------------------  Successfully opened driver \"%S\"\n", driver_desc->file);

  785. 

  786.         

  787.     fInitialize = (driverInitialize)GetDriverProc(fHandle, "driver_initialize");

  788. 

  789. #ifdef WIN32

  790.     if ((fInitialize == NULL) && (errstr = GetLastError ()) != 0) {

  791. #else

  792.     if ((fInitialize == NULL) && (errstr = dlerror ()) != 0) {

  793. #endif

  794. 

  795. #ifdef WIN32

  796.         jack_error("No initialize function in shared object %S\n", driver_desc->file);

  797. #else

  798.         jack_error("No initialize function in shared object %s\n", driver_desc->file);

  799. #endif

  800.         return NULL;

  801.     }

  802. 

  803.     fBackend = fInitialize(engine, synchro, params);

  804.     return fBackend;

  805. }

  806. 

  807. JackDriverInfo::~JackDriverInfo()

  808. {

  809.     delete fBackend;

  810.     if (fHandle) {

  811.         UnloadDriverModule(fHandle);

  812.     }

  813. }

  814. 

  815. SERVER_EXPORT jack_driver_desc_t* jack_driver_descriptor_construct(

  816.     const char * name,

  817.     jack_driver_type_t type,

  818.     const char * description,

  819.     jack_driver_desc_filler_t * filler_ptr)

  820. {

  821.     size_t name_len;

  822.     size_t description_len;

  823.     jack_driver_desc_t* desc_ptr;

  824. 

  825.     name_len = strlen(name);

  826.     description_len = strlen(description);

  827. 

  828.     if (name_len > sizeof(desc_ptr->name) - 1 ||

  829.         description_len > sizeof(desc_ptr->desc) - 1) {

  830.         assert(false);

  831.         return 0;

  832.     }

  833. 

  834.     desc_ptr = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));

  835.     if (desc_ptr == NULL) {

  836.         jack_error("Error calloc() failed to allocate memory for driver descriptor struct");

  837.         return 0;

  838.     }

  839. 

  840.     memcpy(desc_ptr->name, name, name_len + 1);

  841.     memcpy(desc_ptr->desc, description, description_len + 1);

  842. 

  843.     desc_ptr->nparams = 0;

  844.     desc_ptr->type = type;

  845. 

  846.     if (filler_ptr != NULL) {

  847.         filler_ptr->size = 0;

  848.     }

  849. 

  850.     return desc_ptr;

  851. }

  852. 

  853. SERVER_EXPORT int jack_driver_descriptor_add_parameter(

  854.     jack_driver_desc_t* desc_ptr,

  855.     jack_driver_desc_filler_t * filler_ptr,

  856.     const char* name,

  857.     char character,

  858.     jack_driver_param_type_t type,

  859.     const jack_driver_param_value_t * value_ptr,

  860.     jack_driver_param_constraint_desc_t * constraint,

  861.     const char* short_desc,

  862.     const char* long_desc)

  863. {

  864.     size_t name_len;

  865.     size_t short_desc_len;

  866.     size_t long_desc_len;

  867.     jack_driver_param_desc_t * param_ptr;

  868.     size_t newsize;

  869. 

  870.     name_len = strlen(name);

  871.     short_desc_len = strlen(short_desc);

  872. 

  873.     if (long_desc != NULL) {

  874.         long_desc_len = strlen(long_desc);

  875.     } else {

  876.         long_desc = short_desc;

  877.         long_desc_len = short_desc_len;

  878.     }

  879. 

  880.     if (name_len > sizeof(param_ptr->name) - 1 ||

  881.         short_desc_len > sizeof(param_ptr->short_desc) - 1 ||

  882.         long_desc_len > sizeof(param_ptr->long_desc) - 1) {

  883.         assert(false);

  884.         return 0;

  885.     }

  886. 

  887.     if (desc_ptr->nparams == filler_ptr->size) {

  888.         newsize = filler_ptr->size + 20; // most drivers have less than 20 parameters

  889.         param_ptr = (jack_driver_param_desc_t*)realloc (desc_ptr->params, newsize * sizeof (jack_driver_param_desc_t));

  890.         if (param_ptr == NULL) {

  891.             jack_error("Error realloc() failed for parameter array of %zu elements", newsize);

  892.             return false;

  893.         }

  894.         filler_ptr->size = newsize;

  895.         desc_ptr->params = param_ptr;

  896.     }

  897. 

  898.     assert(desc_ptr->nparams < filler_ptr->size);

  899.     param_ptr = desc_ptr->params + desc_ptr->nparams;

  900. 

  901.     memcpy(param_ptr->name, name, name_len + 1);

  902.     param_ptr->character = character;

  903.     param_ptr->type = type;

  904.     param_ptr->value = *value_ptr;

  905.     param_ptr->constraint = constraint;

  906.     memcpy(param_ptr->short_desc, short_desc, short_desc_len + 1);

  907.     memcpy(param_ptr->long_desc, long_desc, long_desc_len + 1);

  908. 

  909.     desc_ptr->nparams++;

  910.     return true;

  911. }

  912. 

  913. SERVER_EXPORT

  914. int

  915. jack_constraint_add_enum(

  916.     jack_driver_param_constraint_desc_t ** constraint_ptr_ptr,

  917.     uint32_t * array_size_ptr,

  918.     jack_driver_param_value_t * value_ptr,

  919.     const char * short_desc)

  920. {

  921.     jack_driver_param_constraint_desc_t * constraint_ptr;

  922.     uint32_t array_size;

  923.     jack_driver_param_value_enum_t * possible_value_ptr;

  924.     size_t len;

  925. 

  926.     len = strlen(short_desc) + 1;

  927.     if (len > sizeof(possible_value_ptr->short_desc))

  928.     {

  929.         assert(false);

  930.         return false;

  931.     }

  932. 

  933.     constraint_ptr = *constraint_ptr_ptr;

  934.     if (constraint_ptr == NULL)

  935.     {

  936.         constraint_ptr = (jack_driver_param_constraint_desc_t *)calloc(1, sizeof(jack_driver_param_constraint_desc_t));

  937.         if (constraint_ptr == NULL)

  938.         {

  939.             jack_error("calloc() failed to allocate memory for param constraint struct");

  940.             return false;

  941.         }

  942. 

  943.         array_size = 0;

  944.     }

  945.     else

  946.     {

  947.         array_size = *array_size_ptr;

  948.     }

  949. 

  950.     if (constraint_ptr->constraint.enumeration.count == array_size)

  951.     {

  952.         array_size += 10;

  953.         possible_value_ptr =

  954.             (jack_driver_param_value_enum_t *)realloc(

  955.                 constraint_ptr->constraint.enumeration.possible_values_array,

  956.                 sizeof(jack_driver_param_value_enum_t) * array_size);

  957.         if (possible_value_ptr == NULL)

  958.         {

  959.             jack_error("realloc() failed to (re)allocate memory for possible values array");

  960.             return false;

  961.         }

  962.         constraint_ptr->constraint.enumeration.possible_values_array = possible_value_ptr;

  963.     }

  964.     else

  965.     {

  966.         possible_value_ptr = constraint_ptr->constraint.enumeration.possible_values_array;

  967.     }

  968. 

  969.     possible_value_ptr += constraint_ptr->constraint.enumeration.count;

  970.     constraint_ptr->constraint.enumeration.count++;

  971. 

  972.     possible_value_ptr->value = *value_ptr;

  973.     memcpy(possible_value_ptr->short_desc, short_desc, len);

  974. 

  975.     *constraint_ptr_ptr = constraint_ptr;

  976.     *array_size_ptr = array_size;

  977. 

  978.     return true;

  979. }

  980. 

  981. SERVER_EXPORT

  982. void

  983. jack_constraint_free(

  984.     jack_driver_param_constraint_desc_t * constraint_ptr)

  985. {

  986.     if (constraint_ptr != NULL)

  987.     {

  988.         if ((constraint_ptr->flags & JACK_CONSTRAINT_FLAG_RANGE) == 0)

  989.         {

  990.             free(constraint_ptr->constraint.enumeration.possible_values_array);

  991.         }

  992. 

  993.         free(constraint_ptr);

  994.     }

  995. }

  996. 

  997. #define JACK_CONSTRAINT_COMPOSE_ENUM_IMPL(type, copy)                   \

  998. JACK_CONSTRAINT_COMPOSE_ENUM(type)                                      \

  999. {                                                                       \

  1000.     jack_driver_param_constraint_desc_t * constraint_ptr;               \

  1001.     uint32_t array_size;                                                \

  1002.     jack_driver_param_value_t value;                                    \

  1003.     struct jack_constraint_enum_ ## type ## _descriptor * descr_ptr;    \

  1004.                                                                         \

  1005.     constraint_ptr = NULL;                                              \

  1006.     for (descr_ptr = descr_array_ptr;                                   \

  1007.          descr_ptr->value;                                              \

  1008.          descr_ptr++)                                                   \

  1009.     {                                                                   \

  1010.         copy;                                                           \

  1011.         if (!jack_constraint_add_enum(                                  \

  1012.                 &constraint_ptr,                                        \

  1013.                 &array_size,                                            \

  1014.                 &value,                                                 \

  1015.                 descr_ptr->short_desc))                                 \

  1016.         {                                                               \

  1017.             jack_constraint_free(constraint_ptr);                       \

  1018.             return NULL;                                                \

  1019.         }                                                               \

  1020.     }                                                                   \

  1021.                                                                         \

  1022.     constraint_ptr->flags = flags;                                      \

  1023.                                                                         \

  1024.     return constraint_ptr;                                              \

  1025. }

  1026. 

  1027. JACK_CONSTRAINT_COMPOSE_ENUM_IMPL(uint32, value.c = descr_ptr->value);

  1028. JACK_CONSTRAINT_COMPOSE_ENUM_IMPL(sint32, value.c = descr_ptr->value);

  1029. JACK_CONSTRAINT_COMPOSE_ENUM_IMPL(char,   value.c = descr_ptr->value);

  1030. JACK_CONSTRAINT_COMPOSE_ENUM_IMPL(str, strcpy(value.str, descr_ptr->value));