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.
2682 Commits
8 Branches
255MB
Tree: 9c6afc5157
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9c6afc5157'
${ noResults }
jack2/common/JackDriverLoader.cpp

946 lines
28KB
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. 

  37. static char* locate_application_driver_dir()

  38. {

  39.     char driver_dir_storage[512];

  40. 

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

  42.     if (3 < GetModuleFileName(NULL, driver_dir_storage, 512)) {

  43.         char *p = strrchr(driver_dir_storage, '\\');

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

  45.             *p = 0;

  46.         } else {

  47.             GetCurrentDirectory(512, driver_dir_storage);

  48.         }

  49.     } else {

  50.         GetCurrentDirectory(512, driver_dir_storage);

  51.     }

  52. 

  53.     strcat(driver_dir_storage, "/");

  54.     strcat(driver_dir_storage, ADDON_DIR);

  55.     return strdup(driver_dir_storage);

  56. }

  57. 

  58. static char* locate_system_driver_dir()

  59. {

  60.     char driver_dir_storage[512];

  61. 

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

  63.     if (3 < GetSystemDirectory(driver_dir_storage, 512)) {

  64.         strcat(driver_dir_storage, "/");

  65.         strcat(driver_dir_storage, ADDON_DIR);

  66.         return strdup(driver_dir_storage);

  67.     } else {

  68.         jack_error("Cannot get system directory : %d", GetLastError());

  69.         return NULL;

  70.     }

  71. }

  72. 

  73. static char* locate_driver_dir(HANDLE& file, WIN32_FIND_DATA& filedata)

  74. {

  75.     char dll_filename[512];

  76. 

  77.     // Search drivers/internals near the application

  78.     char* driver_dir = locate_application_driver_dir();

  79.     snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  80.     file = (HANDLE)FindFirstFile(dll_filename, &filedata);

  81. 

  82.     if (file == INVALID_HANDLE_VALUE) {

  83.         jack_error("Drivers not found near application");

  84. 

  85.         // Otherwise search drivers/internals in the system

  86.         free(driver_dir);

  87.         driver_dir = locate_system_driver_dir();

  88.         snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  89.         file = (HANDLE)FindFirstFile(dll_filename, &filedata);

  90. 

  91.         if (file == INVALID_HANDLE_VALUE) {

  92.             jack_error("Drivers not found in system location");

  93.             free(driver_dir);

  94.             return NULL;

  95.         }

  96.     }

  97. 

  98.     return driver_dir;

  99. }

  100. 

  101. #endif

  102. 

  103. jack_driver_desc_t* jackctl_driver_get_desc(jackctl_driver_t * driver);

  104. 

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

  106. {

  107.     unsigned long i;

  108.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  109. 

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

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

  112.             case JackDriverParamInt:

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

  114.                 break;

  115.             case JackDriverParamUInt:

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

  117.                 break;

  118.             case JackDriverParamChar:

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

  120.                 break;

  121.             case JackDriverParamString:

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

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

  124.                 } else {

  125.                     sprintf (arg_default, "none");

  126.                 }

  127.                 break;

  128.             case JackDriverParamBool:

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

  130.                 break;

  131.         }

  132. 

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

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

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

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

  137.                  arg_default);

  138.     }

  139. }

  140. 

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

  142. {

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

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

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

  146. }

  147. 

  148. void jack_free_driver_params(JSList * driver_params)

  149. {

  150.     JSList*node_ptr = driver_params;

  151.     JSList*next_node_ptr;

  152. 

  153.     while (node_ptr) {

  154.         next_node_ptr = node_ptr->next;

  155.         free(node_ptr->data);

  156.         free(node_ptr);

  157.         node_ptr = next_node_ptr;

  158.     }

  159. }

  160. 

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

  162. {

  163.     struct option * long_options;

  164.     char* options, * options_ptr;

  165.     unsigned long i;

  166.     int opt;

  167.     unsigned int param_index;

  168.     JSList* params = NULL;

  169.     jack_driver_param_t * driver_param;

  170. 

  171.     if (argc <= 1) {

  172.         *param_ptr = NULL;

  173.         return 0;

  174.     }

  175. 

  176.     /* check for help */

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

  178.         if (argc > 2) {

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

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

  181.                     jack_print_driver_param_usage (desc, i, stdout);

  182.                     return 1;

  183.                 }

  184.             }

  185. 

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

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

  188.                      desc->name);

  189.         }

  190. 

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

  192.         jack_print_driver_options (desc, stdout);

  193.         return 1;

  194.     }

  195. 

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

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

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

  199. 

  200.     options_ptr = options;

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

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

  203.         options_ptr += 3;

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

  205.         long_options[i].flag = NULL;

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

  207.         long_options[i].has_arg = optional_argument;

  208.     }

  209. 

  210.     /* create the params */

  211.     optind = 0;

  212.     opterr = 0;

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

  214. 

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

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

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

  218.             } else {

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

  220.             }

  221. 

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

  223.             jack_print_driver_options (desc, stderr);

  224.             return 1;

  225.         }

  226. 

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

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

  229.                 break;

  230.             }

  231.         }

  232. 

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

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

  235. 

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

  237.                 strlen(argv[optind]) &&

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

  239.             optarg = argv[optind];

  240.         }

  241. 

  242.         if (optarg) {

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

  244.                 case JackDriverParamInt:

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

  246.                     break;

  247.                 case JackDriverParamUInt:

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

  249.                     break;

  250.                 case JackDriverParamChar:

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

  252.                     break;

  253.                 case JackDriverParamString:

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

  255.                     break;

  256.                 case JackDriverParamBool:

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

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

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

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

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

  262.                         driver_param->value.i = false;

  263.                     } else {

  264.                         driver_param->value.i = true;

  265.                     }

  266.                     break;

  267.             }

  268.         } else {

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

  270.                 driver_param->value.i = true;

  271.             } else {

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

  273.             }

  274.         }

  275. 

  276.         params = jack_slist_append (params, driver_param);

  277.     }

  278. 

  279.     free (options);

  280.     free (long_options);

  281. 

  282.     if (param_ptr) {

  283.         *param_ptr = params;

  284.     }

  285.     return 0;

  286. }

  287. 

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

  289. {

  290.     struct option* long_options;

  291.     char* options, * options_ptr;

  292.     unsigned long i;

  293.     int opt;

  294.     JSList* node_ptr;

  295.     jackctl_parameter_t * param = NULL;

  296.     union jackctl_parameter_value value;

  297. 

  298.     if (argc <= 1) {

  299.         return 0;

  300.     }

  301. 

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

  303.     if (driver_params == NULL) {

  304.         return 1;

  305.     }

  306. 

  307.     jack_driver_desc_t* desc = jackctl_driver_get_desc(driver_ptr);

  308. 

  309.     /* check for help */

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

  311.         if (argc > 2) {

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

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

  314.                     jack_print_driver_param_usage (desc, i, stdout);

  315.                     return 1;

  316.                 }

  317.             }

  318. 

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

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

  321.                      desc->name);

  322.         }

  323. 

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

  325.         jack_print_driver_options (desc, stdout);

  326.         return 1;

  327.     }

  328. 

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

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

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

  332. 

  333.     options_ptr = options;

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

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

  336.         options_ptr += 3;

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

  338.         long_options[i].flag = NULL;

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

  340.         long_options[i].has_arg = optional_argument;

  341.     }

  342. 

  343.     /* create the params */

  344.     optind = 0;

  345.     opterr = 0;

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

  347. 

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

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

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

  351.             } else {

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

  353.             }

  354. 

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

  356.             jack_print_driver_options(desc, stderr);

  357.             return 1;

  358.         }

  359. 

  360.         node_ptr = (JSList *)driver_params;

  361.        	while (node_ptr) {

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

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

  364.                 break;

  365.             }

  366.             node_ptr = node_ptr->next;

  367.         }

  368. 

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

  370.             strlen(argv[optind]) &&

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

  372.             optarg = argv[optind];

  373.         }

  374. 

  375.         if (optarg) {

  376.             switch (jackctl_parameter_get_type(param)) {

  377.                 case JackDriverParamInt:

  378.                     value.i = atoi(optarg);

  379.                     jackctl_parameter_set_value(param, &value);

  380.                     break;

  381.                 case JackDriverParamUInt:

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

  383.                     jackctl_parameter_set_value(param, &value);

  384.                     break;

  385.                 case JackDriverParamChar:

  386.                     value.c = optarg[0];

  387.                     jackctl_parameter_set_value(param, &value);

  388.                     break;

  389.                 case JackDriverParamString:

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

  391.                     jackctl_parameter_set_value(param, &value);

  392.                     break;

  393.                 case JackDriverParamBool:

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

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

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

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

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

  399.                         value.i = false;

  400.                     } else {

  401.                         value.i = true;

  402.                     }

  403.                     jackctl_parameter_set_value(param, &value);

  404.                     break;

  405.             }

  406.         } else {

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

  408.                 value.i = true;

  409.             } else {

  410.                 value = jackctl_parameter_get_default_value(param);

  411.             }

  412.             jackctl_parameter_set_value(param, &value);

  413.         }

  414.     }

  415. 

  416.     free(options);

  417.     free(long_options);

  418.     return 0;

  419. }

  420. 

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

  422. {

  423.     jack_driver_desc_t* desc = 0;

  424.     JSList* node;

  425. 

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

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

  428. 

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

  430.             desc = NULL;

  431.         } else {

  432.             break;

  433.         }

  434.     }

  435. 

  436.     return desc;

  437. }

  438. 

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

  440. {

  441.     void* dlhandle;

  442.     void* res = NULL;

  443.     char filename[1024];

  444.     sprintf(filename, "%s/%s", driver_dir, sofile);

  445. 

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

  447. #ifdef WIN32

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

  449. #else

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

  451. #endif

  452.     } else {

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

  454.         if (res_dllhandle) {

  455.             *res_dllhandle = dlhandle;

  456.         } else {

  457.             UnloadDriverModule(dlhandle);

  458.         }

  459.     }

  460. 

  461.     return res;

  462. }

  463. 

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

  465. {

  466.     jack_driver_desc_t* descriptor = NULL;

  467.     jack_driver_desc_t* other_descriptor;

  468.     JackDriverDescFunction so_get_descriptor = NULL;

  469.     char filename[1024];

  470.     JSList* node;

  471.     void* dlhandle;

  472. 

  473.     sprintf(filename, "%s/%s", driver_dir, sofile);

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

  475. 

  476.     if (so_get_descriptor == NULL) {

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

  478.         goto error;

  479.     }

  480. 

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

  482.         jack_error("Driver from '%s' returned NULL descriptor", filename);

  483.         goto error;

  484.     }

  485. 

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

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

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

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

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

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

  492.             /* FIXME: delete the descriptor */

  493.             goto error;

  494.         }

  495.     }

  496. 

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

  498. 

  499. error:

  500. 

  501.     UnloadDriverModule(dlhandle);

  502.     return descriptor;

  503. }

  504. 

  505. #ifdef WIN32

  506. 

  507. JSList * jack_drivers_load(JSList * drivers)

  508. {

  509.     //char dll_filename[512];

  510.     WIN32_FIND_DATA filedata;

  511.     HANDLE file;

  512.     const char* ptr = NULL;

  513.     JSList* driver_list = NULL;

  514.     jack_driver_desc_t* desc = NULL;

  515. 

  516.     char* driver_dir = locate_driver_dir(file, filedata);

  517.     if (!driver_dir) {

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

  519.         goto error;

  520.     }

  521. 

  522.     /*

  523.     char* driver_dir = locate_application_driver_dir();

  524.     snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  525.     file = (HANDLE)FindFirstFile(dll_filename, &filedata);

  526. 

  527.     if (file == INVALID_HANDLE_VALUE) {

  528.         jack_error("Drivers not found near application");

  529. 

  530.         // Now try system; location

  531.         free(driver_dir);

  532.         driver_dir = locate_system_driver_dir();

  533.         snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  534.         file = (HANDLE)FindFirstFile(dll_filename, &filedata);

  535. 

  536.         if (file == INVALID_HANDLE_VALUE) {

  537.             jack_error("Drivers not found in system location");

  538.             free(driver_dir);

  539.             return NULL;

  540.         }

  541.     }

  542.     */

  543. 

  544.     do {

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

  546.         if (strncmp ("jack_", filedata.cFileName, 5) != 0) {

  547.             continue;

  548.         }

  549. 

  550.         ptr = strrchr (filedata.cFileName, '.');

  551.         if (!ptr) {

  552.             continue;

  553.         }

  554. 

  555.         ptr++;

  556.         if (strncmp ("dll", ptr, 3) != 0) {

  557.             continue;

  558.         }

  559. 

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

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

  562.             continue;

  563.         }

  564. 

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

  566.         if (desc) {

  567.             driver_list = jack_slist_append (driver_list, desc);

  568.         } else {

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

  570.         }

  571. 

  572.     } while (FindNextFile(file, &filedata));

  573. 

  574.     if (!driver_list) {

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

  576.     }

  577. 

  578. error:

  579.     if (driver_dir) {

  580.         free(driver_dir);

  581.     }

  582.     FindClose(file);

  583.     return driver_list;

  584. }

  585. 

  586. #else

  587. 

  588. JSList* jack_drivers_load (JSList * drivers)

  589. {

  590.     struct dirent * dir_entry;

  591.     DIR * dir_stream;

  592.     const char* ptr;

  593.     int err;

  594.     JSList* driver_list = NULL;

  595.     jack_driver_desc_t* desc = NULL;

  596. 

  597.     const char* driver_dir;

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

  599.         driver_dir = ADDON_DIR;

  600.     }

  601. 

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

  603.     from the .so files in it */

  604.     dir_stream = opendir (driver_dir);

  605.     if (!dir_stream) {

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

  607.                     driver_dir, strerror (errno));

  608.         return NULL;

  609.     }

  610. 

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

  612. 

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

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

  615.             continue;

  616.         }

  617. 

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

  619.         if (!ptr) {

  620.             continue;

  621.         }

  622.         ptr++;

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

  624.             continue;

  625.         }

  626. 

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

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

  629.             continue;

  630.         }

  631. 

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

  633.         if (desc) {

  634.             driver_list = jack_slist_append (driver_list, desc);

  635.         } else {

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

  637.         }

  638.     }

  639. 

  640.     err = closedir (dir_stream);

  641.     if (err) {

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

  643.                     driver_dir, strerror (errno));

  644.     }

  645. 

  646.     if (!driver_list) {

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

  648.         return NULL;

  649.     }

  650. 

  651.     return driver_list;

  652. }

  653. 

  654. #endif

  655. 

  656. #ifdef WIN32

  657. 

  658. JSList* jack_internals_load(JSList * internals)

  659. {

  660.     ///char dll_filename[512];

  661.     WIN32_FIND_DATA filedata;

  662.     HANDLE file;

  663.     const char* ptr = NULL;

  664.     JSList* driver_list = NULL;

  665.     jack_driver_desc_t* desc;

  666. 

  667.     char* driver_dir = locate_driver_dir(file, filedata);

  668.     if (!driver_dir) {

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

  670.         goto error;

  671.     }

  672. 

  673.     /*

  674.     char* driver_dir = locate_application_driver_dir();

  675.     snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  676.     file = (HANDLE)FindFirstFile(dll_filename, &filedata);

  677. 

  678.     if (file == INVALID_HANDLE_VALUE) {

  679.         jack_error("Drivers not found near application");

  680. 

  681.         // Now try system; location

  682.         free(driver_dir);

  683.         driver_dir = locate_system_driver_dir();

  684.         snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  685.         file = (HANDLE)FindFirstFile(dll_filename, &filedata);

  686. 

  687.         if (file == INVALID_HANDLE_VALUE) {

  688.             jack_error("Drivers not found in system location");

  689.             free(driver_dir);

  690.             return NULL;

  691.         }

  692.     }

  693.     */

  694.     do {

  695. 

  696.         ptr = strrchr (filedata.cFileName, '.');

  697.         if (!ptr) {

  698.             continue;

  699.         }

  700. 

  701.         ptr++;

  702.         if (strncmp ("dll", ptr, 3) != 0) {

  703.             continue;

  704.         }

  705. 

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

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

  708.             continue;

  709.         }

  710. 

  711.         desc = jack_get_descriptor (internals, filedata.cFileName, "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\'", filedata.cFileName);

  716.         }

  717. 

  718.     } while (FindNextFile(file, &filedata));

  719. 

  720.     if (!driver_list) {

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

  722.     }

  723. 

  724.  error:

  725.     if (driver_dir) {

  726.         free(driver_dir);

  727.     }

  728.     FindClose(file);

  729.     return driver_list;

  730. }

  731. 

  732. #else

  733. 

  734. JSList* jack_internals_load(JSList * internals)

  735. {

  736.     struct dirent * dir_entry;

  737.     DIR * dir_stream;

  738.     const char* ptr;

  739.     int err;

  740.     JSList* driver_list = NULL;

  741.     jack_driver_desc_t* desc;

  742. 

  743.     const char* driver_dir;

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

  745.         driver_dir = ADDON_DIR;

  746.     }

  747. 

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

  749.     from the .so files in it */

  750.     dir_stream = opendir (driver_dir);

  751.     if (!dir_stream) {

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

  753.                     driver_dir, strerror (errno));

  754.         return NULL;

  755.     }

  756. 

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

  758. 

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

  760.         if (!ptr) {

  761.             continue;

  762.         }

  763. 

  764.         ptr++;

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

  766.             continue;

  767.         }

  768. 

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

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

  771.             continue;

  772.         }

  773. 

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

  775.         if (desc) {

  776.             driver_list = jack_slist_append (driver_list, desc);

  777.         } else {

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

  779.         }

  780.     }

  781. 

  782.     err = closedir (dir_stream);

  783.     if (err) {

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

  785.                     driver_dir, strerror (errno));

  786.     }

  787. 

  788.     if (!driver_list) {

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

  790.         return NULL;

  791.     }

  792. 

  793.     return driver_list;

  794. }

  795. 

  796. #endif

  797. 

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

  799.                                                     Jack::JackLockedEngine* engine,

  800.                                                     Jack::JackSynchro* synchro,

  801.                                                     const JSList* params)

  802. {

  803. #ifdef WIN32

  804.     int errstr;

  805. #else

  806.     const char* errstr;

  807. #endif

  808. 

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

  810. 

  811.     if (fHandle == NULL) {

  812. #ifdef WIN32

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

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

  815. #else

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

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

  818. #endif

  819. 

  820.         } else {

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

  822.         }

  823.         return NULL;

  824.     }

  825. 

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

  827. 

  828. #ifdef WIN32

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

  830. #else

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

  832. #endif

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

  834.         return NULL;

  835.     }

  836. 

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

  838.     return fBackend;

  839. }

  840. 

  841. JackDriverInfo::~JackDriverInfo()

  842. {

  843.     delete fBackend;

  844.     if (fHandle) {

  845.         UnloadDriverModule(fHandle);

  846.     }

  847. }

  848. 

  849. SERVER_EXPORT jack_driver_desc_t* jack_driver_descriptor_construct(

  850.     const char * name,

  851.     jack_driver_type_t type,

  852.     const char * description,

  853.     jack_driver_desc_filler_t * filler_ptr)

  854. {

  855.     size_t name_len;

  856.     size_t description_len;

  857.     jack_driver_desc_t* desc_ptr;

  858. 

  859.     name_len = strlen(name);

  860.     description_len = strlen(description);

  861. 

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

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

  864.         assert(false);

  865.         return 0;

  866.     }

  867. 

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

  869.     if (desc_ptr == NULL) {

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

  871.         return 0;

  872.     }

  873. 

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

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

  876. 

  877.     desc_ptr->nparams = 0;

  878.     desc_ptr->type = type;

  879. 

  880.     if (filler_ptr != NULL) {

  881.         filler_ptr->size = 0;

  882.     }

  883. 

  884.     return desc_ptr;

  885. }

  886. 

  887. SERVER_EXPORT int jack_driver_descriptor_add_parameter(

  888.     jack_driver_desc_t* desc_ptr,

  889.     jack_driver_desc_filler_t * filler_ptr,

  890.     const char* name,

  891.     char character,

  892.     jack_driver_param_type_t type,

  893.     const jack_driver_param_value_t * value_ptr,

  894.     jack_driver_param_constraint_desc_t * constraint,

  895.     const char* short_desc,

  896.     const char* long_desc)

  897. {

  898.     size_t name_len;

  899.     size_t short_desc_len;

  900.     size_t long_desc_len;

  901.     jack_driver_param_desc_t * param_ptr;

  902.     size_t newsize;

  903. 

  904.     name_len = strlen(name);

  905.     short_desc_len = strlen(short_desc);

  906. 

  907.     if (long_desc != NULL) {

  908.         long_desc_len = strlen(long_desc);

  909.     } else {

  910.         long_desc = short_desc;

  911.         long_desc_len = short_desc_len;

  912.     }

  913. 

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

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

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

  917.         assert(false);

  918.         return 0;

  919.     }

  920. 

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

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

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

  924.         if (param_ptr == NULL) {

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

  926.             return false;

  927.         }

  928.         filler_ptr->size = newsize;

  929.         desc_ptr->params = param_ptr;

  930.     }

  931. 

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

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

  934. 

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

  936.     param_ptr->character = character;

  937.     param_ptr->type = type;

  938.     param_ptr->value = *value_ptr;

  939.     param_ptr->constraint = constraint;

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

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

  942. 

  943.     desc_ptr->nparams++;

  944.     return true;

  945. }