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.
825 Commits
8 Branches
67MB
Tree: e44ab5b9ad
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e44ab5b9ad'
${ noResults }
jack2/linux/dbus/xml.c

1253 lines
35KB
Raw Blame History 

  1. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  2. /*

  3.     Copyright (C) 2007,2008 Nedko Arnaudov

  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.

  8. 

  9.     This program is distributed in the hope that it will be useful,

  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12.     GNU General Public License for more details.

  13. 

  14.     You should have received a copy of the GNU General Public License

  15.     along with this program; if not, write to the Free Software

  16.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  17. 

  18. */

  19. 

  20. #include <stdbool.h>

  21. #include <stdint.h>

  22. #include <string.h>

  23. #include <stdio.h>

  24. #include <dbus/dbus.h>

  25. 

  26. #include "controller_internal.h"

  27. 

  28. void

  29. jack_controller_settings_set_bool_option(

  30.     const char *value_str,

  31.     int *value_ptr)

  32. {

  33.     if (strcmp(value_str, "true") == 0)

  34.     {

  35.         *value_ptr = true;

  36.     }

  37.     else if (strcmp(value_str, "false") == 0)

  38.     {

  39.         *value_ptr = false;

  40.     }

  41.     else

  42.     {

  43.         jack_error("ignoring unknown bool value \"%s\"", value_str);

  44.     }

  45. }

  46. 

  47. void

  48. jack_controller_settings_set_sint_option(

  49.     const char *value_str,

  50.     int *value_ptr)

  51. {

  52.     *value_ptr = atoi(value_str);

  53. }

  54. 

  55. void

  56. jack_controller_settings_set_uint_option(

  57.     const char *value_str,

  58.     unsigned int *value_ptr)

  59. {

  60.     *value_ptr = strtoul(value_str, NULL, 10);

  61. }

  62. 

  63. void

  64. jack_controller_settings_set_char_option(

  65.     const char *value_str,

  66.     char *value_ptr)

  67. {

  68.     if (value_str[0] == 0 || value_str[1] != 0)

  69.     {

  70.         jack_error("invalid char option value \"%s\"", value_str);

  71.         return;

  72.     }

  73. 

  74.     *value_ptr = *value_str;

  75. }

  76. 

  77. void

  78. jack_controller_settings_set_string_option(

  79.     const char *value_str,

  80.     char *value_ptr,

  81.     size_t max_size)

  82. {

  83.     size_t size;

  84. 

  85.     size = strlen(value_str);

  86. 

  87.     if (size >= max_size)

  88.     {

  89.         jack_error("string option value \"%s\" is too long, max is %u chars (including terminating zero)", value_str, (unsigned int)max_size);

  90.         return;

  91.     }

  92. 

  93.     strcpy(value_ptr, value_str);

  94. }

  95. 

  96. void

  97. jack_controller_settings_set_driver_option(

  98.     jackctl_driver_t *driver,

  99.     const char *option_name,

  100.     const char *option_value)

  101. {

  102.     jackctl_parameter_t *parameter;

  103.     jackctl_param_type_t type;

  104.     int value_int;

  105.     unsigned int value_uint;

  106.     union jackctl_parameter_value value;

  107. 

  108.     jack_info("setting driver option \"%s\" to value \"%s\"", option_name, option_value);

  109. 

  110.     parameter = jack_controller_find_parameter(jackctl_driver_get_parameters(driver), option_name);

  111.     if (parameter == NULL)

  112.     {

  113.         jack_error(

  114.             "Unknown parameter \"%s\" of driver \"%s\"",

  115.             option_name,

  116.             jackctl_driver_get_name(driver));

  117.         return;

  118.     }

  119. 

  120.     type = jackctl_parameter_get_type(parameter);

  121. 

  122.     switch (type)

  123.     {

  124.     case JackParamInt:

  125.         jack_controller_settings_set_sint_option(option_value, &value_int);

  126.         value.i = value_int;

  127.         break;

  128.     case JackParamUInt:

  129.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  130.         value.ui = value_uint;

  131.         break;

  132.     case JackParamChar:

  133.         jack_controller_settings_set_char_option(option_value, &value.c);

  134.         break;

  135.     case JackParamString:

  136.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  137.         break;

  138.     case JackParamBool:

  139.         jack_controller_settings_set_bool_option(option_value, &value_int);

  140.         value.i = value_int;

  141.         break;

  142.     default:

  143.         jack_error("Parameter \"%s\" of driver \"%s\" is of unknown type %d",

  144.                jackctl_parameter_get_name(parameter),

  145.                jackctl_driver_get_name(driver),

  146.                type);

  147.     }

  148. 

  149.     jackctl_parameter_set_value(parameter, &value);

  150. }

  151. 

  152. void

  153. jack_controller_settings_set_engine_option(

  154.     struct jack_controller *controller_ptr,

  155.     const char *option_name,

  156.     const char *option_value)

  157. {

  158.     jackctl_parameter_t *parameter;

  159.     jackctl_param_type_t type;

  160.     int value_int;

  161.     unsigned int value_uint;

  162.     union jackctl_parameter_value value;

  163. 

  164.     jack_info("setting engine option \"%s\" to value \"%s\"", option_name, option_value);

  165. 

  166.     if (strcmp(option_name, "driver") == 0)

  167.     {

  168.         if (!jack_controller_select_driver(controller_ptr, option_value))

  169.         {

  170.             jack_error("unknown driver '%s'", option_value);

  171.         }

  172. 

  173.         return;

  174.     }

  175. 

  176.     parameter = jack_controller_find_parameter(jackctl_server_get_parameters(controller_ptr->server), option_name);

  177.     if (parameter == NULL)

  178.     {

  179.         jack_error(

  180.             "Unknown engine parameter \"%s\"",

  181.             option_name);

  182.         return;

  183.     }

  184. 

  185.     type = jackctl_parameter_get_type(parameter);

  186. 

  187.     switch (type)

  188.     {

  189.     case JackParamInt:

  190.         jack_controller_settings_set_sint_option(option_value, &value_int);

  191.         value.i = value_int;

  192.         break;

  193.     case JackParamUInt:

  194.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  195.         value.ui = value_uint;

  196.         break;

  197.     case JackParamChar:

  198.         jack_controller_settings_set_char_option(option_value, &value.c);

  199.         break;

  200.     case JackParamString:

  201.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  202.         break;

  203.     case JackParamBool:

  204.         jack_controller_settings_set_bool_option(option_value, &value_int);

  205.         value.i = value_int;

  206.         break;

  207.     default:

  208.         jack_error("Engine parameter \"%s\" is of unknown type %d",

  209.                jackctl_parameter_get_name(parameter),

  210.                type);

  211.     }

  212. 

  213.     jackctl_parameter_set_value(parameter, &value);

  214. }

  215. 

  216. static

  217. bool

  218. jack_controller_settings_save_options(

  219.     void *context,

  220.     const JSList * parameters_list,

  221.     void *dbus_call_context_ptr)

  222. {

  223.     jackctl_parameter_t *parameter;

  224.     jackctl_param_type_t type;

  225.     union jackctl_parameter_value value;

  226.     const char * name;

  227.     char value_str[50];

  228. 

  229.     while (parameters_list != NULL)

  230.     {

  231.         parameter = (jackctl_parameter_t *)parameters_list->data;

  232. 

  233.         if (jackctl_parameter_is_set(parameter))

  234.         {

  235.             type = jackctl_parameter_get_type(parameter);

  236.             value = jackctl_parameter_get_value(parameter);

  237.             name = jackctl_parameter_get_name(parameter);

  238.         

  239.             switch (type)

  240.             {

  241.             case JackParamInt:

  242.                 sprintf(value_str, "%d", (int)value.i);

  243.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  244.                 {

  245.                     return false;

  246.                 }

  247.                 break;

  248.             case JackParamUInt:

  249.                 sprintf(value_str, "%u", (unsigned int)value.ui);

  250.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  251.                 {

  252.                     return false;

  253.                 }

  254.                 break;

  255.             case JackParamChar:

  256.                 sprintf(value_str, "%c", (char)value.c);

  257.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  258.                 {

  259.                     return false;

  260.                 }

  261.                 break;

  262.             case JackParamString:

  263.                 if (!jack_controller_settings_write_option(context, name, value.str, dbus_call_context_ptr))

  264.                 {

  265.                     return false;

  266.                 }

  267.                 break;

  268.             case JackParamBool:

  269.                 if (!jack_controller_settings_write_option(context, name, value.b ? "true" : "false", dbus_call_context_ptr))

  270.                 {

  271.                     return false;

  272.                 }

  273.                 break;

  274.             default:

  275.                 jack_error("parameter of unknown type %d", type);

  276.             }

  277.         }

  278. 

  279.         parameters_list = jack_slist_next(parameters_list);

  280.     }

  281. 

  282.     return true;

  283. }

  284. 

  285. bool

  286. jack_controller_settings_save_engine_options(

  287.     void *context,

  288.     struct jack_controller *controller_ptr,

  289.     void *dbus_call_context_ptr)

  290. {

  291.     if (controller_ptr->driver != NULL)

  292.     {

  293.         if (!jack_controller_settings_write_option(

  294.                 context,

  295.                 "driver",

  296.                 jackctl_driver_get_name(controller_ptr->driver),

  297.                 dbus_call_context_ptr))

  298.         {

  299.             return false;

  300.         }

  301.     }

  302. 

  303.     return jack_controller_settings_save_options(context, jackctl_server_get_parameters(controller_ptr->server), dbus_call_context_ptr);

  304. }

  305. 

  306. bool

  307. jack_controller_settings_save_driver_options(

  308.     void *context,

  309.     jackctl_driver_t *driver,

  310.     void *dbus_call_context_ptr)

  311. {

  312.     return jack_controller_settings_save_options(context, jackctl_driver_get_parameters(driver), dbus_call_context_ptr);

  313. }

  314. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  315. /*

  316.     Copyright (C) 2007,2008 Nedko Arnaudov

  317.     

  318.     This program is free software; you can redistribute it and/or modify

  319.     it under the terms of the GNU General Public License as published by

  320.     the Free Software Foundation; either version 2 of the License.

  321. 

  322.     This program is distributed in the hope that it will be useful,

  323.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  324.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  325.     GNU General Public License for more details.

  326. 

  327.     You should have received a copy of the GNU General Public License

  328.     along with this program; if not, write to the Free Software

  329.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  330. 

  331. */

  332. 

  333. #include <stdbool.h>

  334. #include <stdint.h>

  335. #include <string.h>

  336. #include <stdio.h>

  337. #include <dbus/dbus.h>

  338. 

  339. #include "controller_internal.h"

  340. 

  341. void

  342. jack_controller_settings_set_bool_option(

  343.     const char *value_str,

  344.     int *value_ptr)

  345. {

  346.     if (strcmp(value_str, "true") == 0)

  347.     {

  348.         *value_ptr = true;

  349.     }

  350.     else if (strcmp(value_str, "false") == 0)

  351.     {

  352.         *value_ptr = false;

  353.     }

  354.     else

  355.     {

  356.         jack_error("ignoring unknown bool value \"%s\"", value_str);

  357.     }

  358. }

  359. 

  360. void

  361. jack_controller_settings_set_sint_option(

  362.     const char *value_str,

  363.     int *value_ptr)

  364. {

  365.     *value_ptr = atoi(value_str);

  366. }

  367. 

  368. void

  369. jack_controller_settings_set_uint_option(

  370.     const char *value_str,

  371.     unsigned int *value_ptr)

  372. {

  373.     *value_ptr = strtoul(value_str, NULL, 10);

  374. }

  375. 

  376. void

  377. jack_controller_settings_set_char_option(

  378.     const char *value_str,

  379.     char *value_ptr)

  380. {

  381.     if (value_str[0] == 0 || value_str[1] != 0)

  382.     {

  383.         jack_error("invalid char option value \"%s\"", value_str);

  384.         return;

  385.     }

  386. 

  387.     *value_ptr = *value_str;

  388. }

  389. 

  390. void

  391. jack_controller_settings_set_string_option(

  392.     const char *value_str,

  393.     char *value_ptr,

  394.     size_t max_size)

  395. {

  396.     size_t size;

  397. 

  398.     size = strlen(value_str);

  399. 

  400.     if (size >= max_size)

  401.     {

  402.         jack_error("string option value \"%s\" is too long, max is %u chars (including terminating zero)", value_str, (unsigned int)max_size);

  403.         return;

  404.     }

  405. 

  406.     strcpy(value_ptr, value_str);

  407. }

  408. 

  409. void

  410. jack_controller_settings_set_driver_option(

  411.     jackctl_driver_t *driver,

  412.     const char *option_name,

  413.     const char *option_value)

  414. {

  415.     jackctl_parameter_t *parameter;

  416.     jackctl_param_type_t type;

  417.     int value_int;

  418.     unsigned int value_uint;

  419.     union jackctl_parameter_value value;

  420. 

  421.     jack_info("setting driver option \"%s\" to value \"%s\"", option_name, option_value);

  422. 

  423.     parameter = jack_controller_find_parameter(jackctl_driver_get_parameters(driver), option_name);

  424.     if (parameter == NULL)

  425.     {

  426.         jack_error(

  427.             "Unknown parameter \"%s\" of driver \"%s\"",

  428.             option_name,

  429.             jackctl_driver_get_name(driver));

  430.         return;

  431.     }

  432. 

  433.     type = jackctl_parameter_get_type(parameter);

  434. 

  435.     switch (type)

  436.     {

  437.     case JackParamInt:

  438.         jack_controller_settings_set_sint_option(option_value, &value_int);

  439.         value.i = value_int;

  440.         break;

  441.     case JackParamUInt:

  442.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  443.         value.ui = value_uint;

  444.         break;

  445.     case JackParamChar:

  446.         jack_controller_settings_set_char_option(option_value, &value.c);

  447.         break;

  448.     case JackParamString:

  449.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  450.         break;

  451.     case JackParamBool:

  452.         jack_controller_settings_set_bool_option(option_value, &value_int);

  453.         value.i = value_int;

  454.         break;

  455.     default:

  456.         jack_error("Parameter \"%s\" of driver \"%s\" is of unknown type %d",

  457.                jackctl_parameter_get_name(parameter),

  458.                jackctl_driver_get_name(driver),

  459.                type);

  460.     }

  461. 

  462.     jackctl_parameter_set_value(parameter, &value);

  463. }

  464. 

  465. void

  466. jack_controller_settings_set_engine_option(

  467.     struct jack_controller *controller_ptr,

  468.     const char *option_name,

  469.     const char *option_value)

  470. {

  471.     jackctl_parameter_t *parameter;

  472.     jackctl_param_type_t type;

  473.     int value_int;

  474.     unsigned int value_uint;

  475.     union jackctl_parameter_value value;

  476. 

  477.     jack_info("setting engine option \"%s\" to value \"%s\"", option_name, option_value);

  478. 

  479.     if (strcmp(option_name, "driver") == 0)

  480.     {

  481.         if (!jack_controller_select_driver(controller_ptr, option_value))

  482.         {

  483.             jack_error("unknown driver '%s'", option_value);

  484.         }

  485. 

  486.         return;

  487.     }

  488. 

  489.     parameter = jack_controller_find_parameter(jackctl_server_get_parameters(controller_ptr->server), option_name);

  490.     if (parameter == NULL)

  491.     {

  492.         jack_error(

  493.             "Unknown engine parameter \"%s\"",

  494.             option_name);

  495.         return;

  496.     }

  497. 

  498.     type = jackctl_parameter_get_type(parameter);

  499. 

  500.     switch (type)

  501.     {

  502.     case JackParamInt:

  503.         jack_controller_settings_set_sint_option(option_value, &value_int);

  504.         value.i = value_int;

  505.         break;

  506.     case JackParamUInt:

  507.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  508.         value.ui = value_uint;

  509.         break;

  510.     case JackParamChar:

  511.         jack_controller_settings_set_char_option(option_value, &value.c);

  512.         break;

  513.     case JackParamString:

  514.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  515.         break;

  516.     case JackParamBool:

  517.         jack_controller_settings_set_bool_option(option_value, &value_int);

  518.         value.i = value_int;

  519.         break;

  520.     default:

  521.         jack_error("Engine parameter \"%s\" is of unknown type %d",

  522.                jackctl_parameter_get_name(parameter),

  523.                type);

  524.     }

  525. 

  526.     jackctl_parameter_set_value(parameter, &value);

  527. }

  528. 

  529. static

  530. bool

  531. jack_controller_settings_save_options(

  532.     void *context,

  533.     const JSList * parameters_list,

  534.     void *dbus_call_context_ptr)

  535. {

  536.     jackctl_parameter_t *parameter;

  537.     jackctl_param_type_t type;

  538.     union jackctl_parameter_value value;

  539.     const char * name;

  540.     char value_str[50];

  541. 

  542.     while (parameters_list != NULL)

  543.     {

  544.         parameter = (jackctl_parameter_t *)parameters_list->data;

  545. 

  546.         if (jackctl_parameter_is_set(parameter))

  547.         {

  548.             type = jackctl_parameter_get_type(parameter);

  549.             value = jackctl_parameter_get_value(parameter);

  550.             name = jackctl_parameter_get_name(parameter);

  551.         

  552.             switch (type)

  553.             {

  554.             case JackParamInt:

  555.                 sprintf(value_str, "%d", (int)value.i);

  556.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  557.                 {

  558.                     return false;

  559.                 }

  560.                 break;

  561.             case JackParamUInt:

  562.                 sprintf(value_str, "%u", (unsigned int)value.ui);

  563.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  564.                 {

  565.                     return false;

  566.                 }

  567.                 break;

  568.             case JackParamChar:

  569.                 sprintf(value_str, "%c", (char)value.c);

  570.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  571.                 {

  572.                     return false;

  573.                 }

  574.                 break;

  575.             case JackParamString:

  576.                 if (!jack_controller_settings_write_option(context, name, value.str, dbus_call_context_ptr))

  577.                 {

  578.                     return false;

  579.                 }

  580.                 break;

  581.             case JackParamBool:

  582.                 if (!jack_controller_settings_write_option(context, name, value.b ? "true" : "false", dbus_call_context_ptr))

  583.                 {

  584.                     return false;

  585.                 }

  586.                 break;

  587.             default:

  588.                 jack_error("parameter of unknown type %d", type);

  589.             }

  590.         }

  591. 

  592.         parameters_list = jack_slist_next(parameters_list);

  593.     }

  594. 

  595.     return true;

  596. }

  597. 

  598. bool

  599. jack_controller_settings_save_engine_options(

  600.     void *context,

  601.     struct jack_controller *controller_ptr,

  602.     void *dbus_call_context_ptr)

  603. {

  604.     if (controller_ptr->driver != NULL)

  605.     {

  606.         if (!jack_controller_settings_write_option(

  607.                 context,

  608.                 "driver",

  609.                 jackctl_driver_get_name(controller_ptr->driver),

  610.                 dbus_call_context_ptr))

  611.         {

  612.             return false;

  613.         }

  614.     }

  615. 

  616.     return jack_controller_settings_save_options(context, jackctl_server_get_parameters(controller_ptr->server), dbus_call_context_ptr);

  617. }

  618. 

  619. bool

  620. jack_controller_settings_save_driver_options(

  621.     void *context,

  622.     jackctl_driver_t *driver,

  623.     void *dbus_call_context_ptr)

  624. {

  625.     return jack_controller_settings_save_options(context, jackctl_driver_get_parameters(driver), dbus_call_context_ptr);

  626. }

  627. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  628. /*

  629.     Copyright (C) 2007,2008 Nedko Arnaudov

  630.     

  631.     This program is free software; you can redistribute it and/or modify

  632.     it under the terms of the GNU General Public License as published by

  633.     the Free Software Foundation; either version 2 of the License.

  634. 

  635.     This program is distributed in the hope that it will be useful,

  636.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  637.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  638.     GNU General Public License for more details.

  639. 

  640.     You should have received a copy of the GNU General Public License

  641.     along with this program; if not, write to the Free Software

  642.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  643. 

  644. */

  645. 

  646. #include <stdbool.h>

  647. #include <stdint.h>

  648. #include <string.h>

  649. #include <stdio.h>

  650. #include <dbus/dbus.h>

  651. 

  652. #include "controller_internal.h"

  653. 

  654. void

  655. jack_controller_settings_set_bool_option(

  656.     const char *value_str,

  657.     int *value_ptr)

  658. {

  659.     if (strcmp(value_str, "true") == 0)

  660.     {

  661.         *value_ptr = true;

  662.     }

  663.     else if (strcmp(value_str, "false") == 0)

  664.     {

  665.         *value_ptr = false;

  666.     }

  667.     else

  668.     {

  669.         jack_error("ignoring unknown bool value \"%s\"", value_str);

  670.     }

  671. }

  672. 

  673. void

  674. jack_controller_settings_set_sint_option(

  675.     const char *value_str,

  676.     int *value_ptr)

  677. {

  678.     *value_ptr = atoi(value_str);

  679. }

  680. 

  681. void

  682. jack_controller_settings_set_uint_option(

  683.     const char *value_str,

  684.     unsigned int *value_ptr)

  685. {

  686.     *value_ptr = strtoul(value_str, NULL, 10);

  687. }

  688. 

  689. void

  690. jack_controller_settings_set_char_option(

  691.     const char *value_str,

  692.     char *value_ptr)

  693. {

  694.     if (value_str[0] == 0 || value_str[1] != 0)

  695.     {

  696.         jack_error("invalid char option value \"%s\"", value_str);

  697.         return;

  698.     }

  699. 

  700.     *value_ptr = *value_str;

  701. }

  702. 

  703. void

  704. jack_controller_settings_set_string_option(

  705.     const char *value_str,

  706.     char *value_ptr,

  707.     size_t max_size)

  708. {

  709.     size_t size;

  710. 

  711.     size = strlen(value_str);

  712. 

  713.     if (size >= max_size)

  714.     {

  715.         jack_error("string option value \"%s\" is too long, max is %u chars (including terminating zero)", value_str, (unsigned int)max_size);

  716.         return;

  717.     }

  718. 

  719.     strcpy(value_ptr, value_str);

  720. }

  721. 

  722. void

  723. jack_controller_settings_set_driver_option(

  724.     jackctl_driver_t *driver,

  725.     const char *option_name,

  726.     const char *option_value)

  727. {

  728.     jackctl_parameter_t *parameter;

  729.     jackctl_param_type_t type;

  730.     int value_int;

  731.     unsigned int value_uint;

  732.     union jackctl_parameter_value value;

  733. 

  734.     jack_info("setting driver option \"%s\" to value \"%s\"", option_name, option_value);

  735. 

  736.     parameter = jack_controller_find_parameter(jackctl_driver_get_parameters(driver), option_name);

  737.     if (parameter == NULL)

  738.     {

  739.         jack_error(

  740.             "Unknown parameter \"%s\" of driver \"%s\"",

  741.             option_name,

  742.             jackctl_driver_get_name(driver));

  743.         return;

  744.     }

  745. 

  746.     type = jackctl_parameter_get_type(parameter);

  747. 

  748.     switch (type)

  749.     {

  750.     case JackParamInt:

  751.         jack_controller_settings_set_sint_option(option_value, &value_int);

  752.         value.i = value_int;

  753.         break;

  754.     case JackParamUInt:

  755.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  756.         value.ui = value_uint;

  757.         break;

  758.     case JackParamChar:

  759.         jack_controller_settings_set_char_option(option_value, &value.c);

  760.         break;

  761.     case JackParamString:

  762.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  763.         break;

  764.     case JackParamBool:

  765.         jack_controller_settings_set_bool_option(option_value, &value_int);

  766.         value.i = value_int;

  767.         break;

  768.     default:

  769.         jack_error("Parameter \"%s\" of driver \"%s\" is of unknown type %d",

  770.                jackctl_parameter_get_name(parameter),

  771.                jackctl_driver_get_name(driver),

  772.                type);

  773.     }

  774. 

  775.     jackctl_parameter_set_value(parameter, &value);

  776. }

  777. 

  778. void

  779. jack_controller_settings_set_engine_option(

  780.     struct jack_controller *controller_ptr,

  781.     const char *option_name,

  782.     const char *option_value)

  783. {

  784.     jackctl_parameter_t *parameter;

  785.     jackctl_param_type_t type;

  786.     int value_int;

  787.     unsigned int value_uint;

  788.     union jackctl_parameter_value value;

  789. 

  790.     jack_info("setting engine option \"%s\" to value \"%s\"", option_name, option_value);

  791. 

  792.     if (strcmp(option_name, "driver") == 0)

  793.     {

  794.         if (!jack_controller_select_driver(controller_ptr, option_value))

  795.         {

  796.             jack_error("unknown driver '%s'", option_value);

  797.         }

  798. 

  799.         return;

  800.     }

  801. 

  802.     parameter = jack_controller_find_parameter(jackctl_server_get_parameters(controller_ptr->server), option_name);

  803.     if (parameter == NULL)

  804.     {

  805.         jack_error(

  806.             "Unknown engine parameter \"%s\"",

  807.             option_name);

  808.         return;

  809.     }

  810. 

  811.     type = jackctl_parameter_get_type(parameter);

  812. 

  813.     switch (type)

  814.     {

  815.     case JackParamInt:

  816.         jack_controller_settings_set_sint_option(option_value, &value_int);

  817.         value.i = value_int;

  818.         break;

  819.     case JackParamUInt:

  820.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  821.         value.ui = value_uint;

  822.         break;

  823.     case JackParamChar:

  824.         jack_controller_settings_set_char_option(option_value, &value.c);

  825.         break;

  826.     case JackParamString:

  827.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  828.         break;

  829.     case JackParamBool:

  830.         jack_controller_settings_set_bool_option(option_value, &value_int);

  831.         value.i = value_int;

  832.         break;

  833.     default:

  834.         jack_error("Engine parameter \"%s\" is of unknown type %d",

  835.                jackctl_parameter_get_name(parameter),

  836.                type);

  837.     }

  838. 

  839.     jackctl_parameter_set_value(parameter, &value);

  840. }

  841. 

  842. static

  843. bool

  844. jack_controller_settings_save_options(

  845.     void *context,

  846.     const JSList * parameters_list,

  847.     void *dbus_call_context_ptr)

  848. {

  849.     jackctl_parameter_t *parameter;

  850.     jackctl_param_type_t type;

  851.     union jackctl_parameter_value value;

  852.     const char * name;

  853.     char value_str[50];

  854. 

  855.     while (parameters_list != NULL)

  856.     {

  857.         parameter = (jackctl_parameter_t *)parameters_list->data;

  858. 

  859.         if (jackctl_parameter_is_set(parameter))

  860.         {

  861.             type = jackctl_parameter_get_type(parameter);

  862.             value = jackctl_parameter_get_value(parameter);

  863.             name = jackctl_parameter_get_name(parameter);

  864.         

  865.             switch (type)

  866.             {

  867.             case JackParamInt:

  868.                 sprintf(value_str, "%d", (int)value.i);

  869.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  870.                 {

  871.                     return false;

  872.                 }

  873.                 break;

  874.             case JackParamUInt:

  875.                 sprintf(value_str, "%u", (unsigned int)value.ui);

  876.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  877.                 {

  878.                     return false;

  879.                 }

  880.                 break;

  881.             case JackParamChar:

  882.                 sprintf(value_str, "%c", (char)value.c);

  883.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  884.                 {

  885.                     return false;

  886.                 }

  887.                 break;

  888.             case JackParamString:

  889.                 if (!jack_controller_settings_write_option(context, name, value.str, dbus_call_context_ptr))

  890.                 {

  891.                     return false;

  892.                 }

  893.                 break;

  894.             case JackParamBool:

  895.                 if (!jack_controller_settings_write_option(context, name, value.b ? "true" : "false", dbus_call_context_ptr))

  896.                 {

  897.                     return false;

  898.                 }

  899.                 break;

  900.             default:

  901.                 jack_error("parameter of unknown type %d", type);

  902.             }

  903.         }

  904. 

  905.         parameters_list = jack_slist_next(parameters_list);

  906.     }

  907. 

  908.     return true;

  909. }

  910. 

  911. bool

  912. jack_controller_settings_save_engine_options(

  913.     void *context,

  914.     struct jack_controller *controller_ptr,

  915.     void *dbus_call_context_ptr)

  916. {

  917.     if (controller_ptr->driver != NULL)

  918.     {

  919.         if (!jack_controller_settings_write_option(

  920.                 context,

  921.                 "driver",

  922.                 jackctl_driver_get_name(controller_ptr->driver),

  923.                 dbus_call_context_ptr))

  924.         {

  925.             return false;

  926.         }

  927.     }

  928. 

  929.     return jack_controller_settings_save_options(context, jackctl_server_get_parameters(controller_ptr->server), dbus_call_context_ptr);

  930. }

  931. 

  932. bool

  933. jack_controller_settings_save_driver_options(

  934.     void *context,

  935.     jackctl_driver_t *driver,

  936.     void *dbus_call_context_ptr)

  937. {

  938.     return jack_controller_settings_save_options(context, jackctl_driver_get_parameters(driver), dbus_call_context_ptr);

  939. }

  940. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  941. /*

  942.     Copyright (C) 2007,2008 Nedko Arnaudov

  943.     

  944.     This program is free software; you can redistribute it and/or modify

  945.     it under the terms of the GNU General Public License as published by

  946.     the Free Software Foundation; either version 2 of the License.

  947. 

  948.     This program is distributed in the hope that it will be useful,

  949.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  950.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  951.     GNU General Public License for more details.

  952. 

  953.     You should have received a copy of the GNU General Public License

  954.     along with this program; if not, write to the Free Software

  955.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  956. 

  957. */

  958. 

  959. #include <stdbool.h>

  960. #include <stdint.h>

  961. #include <string.h>

  962. #include <stdio.h>

  963. #include <dbus/dbus.h>

  964. 

  965. #include "controller_internal.h"

  966. 

  967. void

  968. jack_controller_settings_set_bool_option(

  969.     const char *value_str,

  970.     int *value_ptr)

  971. {

  972.     if (strcmp(value_str, "true") == 0)

  973.     {

  974.         *value_ptr = true;

  975.     }

  976.     else if (strcmp(value_str, "false") == 0)

  977.     {

  978.         *value_ptr = false;

  979.     }

  980.     else

  981.     {

  982.         jack_error("ignoring unknown bool value \"%s\"", value_str);

  983.     }

  984. }

  985. 

  986. void

  987. jack_controller_settings_set_sint_option(

  988.     const char *value_str,

  989.     int *value_ptr)

  990. {

  991.     *value_ptr = atoi(value_str);

  992. }

  993. 

  994. void

  995. jack_controller_settings_set_uint_option(

  996.     const char *value_str,

  997.     unsigned int *value_ptr)

  998. {

  999.     *value_ptr = strtoul(value_str, NULL, 10);

  1000. }

  1001. 

  1002. void

  1003. jack_controller_settings_set_char_option(

  1004.     const char *value_str,

  1005.     char *value_ptr)

  1006. {

  1007.     if (value_str[0] == 0 || value_str[1] != 0)

  1008.     {

  1009.         jack_error("invalid char option value \"%s\"", value_str);

  1010.         return;

  1011.     }

  1012. 

  1013.     *value_ptr = *value_str;

  1014. }

  1015. 

  1016. void

  1017. jack_controller_settings_set_string_option(

  1018.     const char *value_str,

  1019.     char *value_ptr,

  1020.     size_t max_size)

  1021. {

  1022.     size_t size;

  1023. 

  1024.     size = strlen(value_str);

  1025. 

  1026.     if (size >= max_size)

  1027.     {

  1028.         jack_error("string option value \"%s\" is too long, max is %u chars (including terminating zero)", value_str, (unsigned int)max_size);

  1029.         return;

  1030.     }

  1031. 

  1032.     strcpy(value_ptr, value_str);

  1033. }

  1034. 

  1035. void

  1036. jack_controller_settings_set_driver_option(

  1037.     jackctl_driver_t *driver,

  1038.     const char *option_name,

  1039.     const char *option_value)

  1040. {

  1041.     jackctl_parameter_t *parameter;

  1042.     jackctl_param_type_t type;

  1043.     int value_int;

  1044.     unsigned int value_uint;

  1045.     union jackctl_parameter_value value;

  1046. 

  1047.     jack_info("setting driver option \"%s\" to value \"%s\"", option_name, option_value);

  1048. 

  1049.     parameter = jack_controller_find_parameter(jackctl_driver_get_parameters(driver), option_name);

  1050.     if (parameter == NULL)

  1051.     {

  1052.         jack_error(

  1053.             "Unknown parameter \"%s\" of driver \"%s\"",

  1054.             option_name,

  1055.             jackctl_driver_get_name(driver));

  1056.         return;

  1057.     }

  1058. 

  1059.     type = jackctl_parameter_get_type(parameter);

  1060. 

  1061.     switch (type)

  1062.     {

  1063.     case JackParamInt:

  1064.         jack_controller_settings_set_sint_option(option_value, &value_int);

  1065.         value.i = value_int;

  1066.         break;

  1067.     case JackParamUInt:

  1068.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  1069.         value.ui = value_uint;

  1070.         break;

  1071.     case JackParamChar:

  1072.         jack_controller_settings_set_char_option(option_value, &value.c);

  1073.         break;

  1074.     case JackParamString:

  1075.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  1076.         break;

  1077.     case JackParamBool:

  1078.         jack_controller_settings_set_bool_option(option_value, &value_int);

  1079.         value.i = value_int;

  1080.         break;

  1081.     default:

  1082.         jack_error("Parameter \"%s\" of driver \"%s\" is of unknown type %d",

  1083.                jackctl_parameter_get_name(parameter),

  1084.                jackctl_driver_get_name(driver),

  1085.                type);

  1086.     }

  1087. 

  1088.     jackctl_parameter_set_value(parameter, &value);

  1089. }

  1090. 

  1091. void

  1092. jack_controller_settings_set_engine_option(

  1093.     struct jack_controller *controller_ptr,

  1094.     const char *option_name,

  1095.     const char *option_value)

  1096. {

  1097.     jackctl_parameter_t *parameter;

  1098.     jackctl_param_type_t type;

  1099.     int value_int;

  1100.     unsigned int value_uint;

  1101.     union jackctl_parameter_value value;

  1102. 

  1103.     jack_info("setting engine option \"%s\" to value \"%s\"", option_name, option_value);

  1104. 

  1105.     if (strcmp(option_name, "driver") == 0)

  1106.     {

  1107.         if (!jack_controller_select_driver(controller_ptr, option_value))

  1108.         {

  1109.             jack_error("unknown driver '%s'", option_value);

  1110.         }

  1111. 

  1112.         return;

  1113.     }

  1114. 

  1115.     parameter = jack_controller_find_parameter(jackctl_server_get_parameters(controller_ptr->server), option_name);

  1116.     if (parameter == NULL)

  1117.     {

  1118.         jack_error(

  1119.             "Unknown engine parameter \"%s\"",

  1120.             option_name);

  1121.         return;

  1122.     }

  1123. 

  1124.     type = jackctl_parameter_get_type(parameter);

  1125. 

  1126.     switch (type)

  1127.     {

  1128.     case JackParamInt:

  1129.         jack_controller_settings_set_sint_option(option_value, &value_int);

  1130.         value.i = value_int;

  1131.         break;

  1132.     case JackParamUInt:

  1133.         jack_controller_settings_set_uint_option(option_value, &value_uint);

  1134.         value.ui = value_uint;

  1135.         break;

  1136.     case JackParamChar:

  1137.         jack_controller_settings_set_char_option(option_value, &value.c);

  1138.         break;

  1139.     case JackParamString:

  1140.         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));

  1141.         break;

  1142.     case JackParamBool:

  1143.         jack_controller_settings_set_bool_option(option_value, &value_int);

  1144.         value.i = value_int;

  1145.         break;

  1146.     default:

  1147.         jack_error("Engine parameter \"%s\" is of unknown type %d",

  1148.                jackctl_parameter_get_name(parameter),

  1149.                type);

  1150.     }

  1151. 

  1152.     jackctl_parameter_set_value(parameter, &value);

  1153. }

  1154. 

  1155. static

  1156. bool

  1157. jack_controller_settings_save_options(

  1158.     void *context,

  1159.     const JSList * parameters_list,

  1160.     void *dbus_call_context_ptr)

  1161. {

  1162.     jackctl_parameter_t *parameter;

  1163.     jackctl_param_type_t type;

  1164.     union jackctl_parameter_value value;

  1165.     const char * name;

  1166.     char value_str[50];

  1167. 

  1168.     while (parameters_list != NULL)

  1169.     {

  1170.         parameter = (jackctl_parameter_t *)parameters_list->data;

  1171. 

  1172.         if (jackctl_parameter_is_set(parameter))

  1173.         {

  1174.             type = jackctl_parameter_get_type(parameter);

  1175.             value = jackctl_parameter_get_value(parameter);

  1176.             name = jackctl_parameter_get_name(parameter);

  1177.         

  1178.             switch (type)

  1179.             {

  1180.             case JackParamInt:

  1181.                 sprintf(value_str, "%d", (int)value.i);

  1182.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  1183.                 {

  1184.                     return false;

  1185.                 }

  1186.                 break;

  1187.             case JackParamUInt:

  1188.                 sprintf(value_str, "%u", (unsigned int)value.ui);

  1189.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  1190.                 {

  1191.                     return false;

  1192.                 }

  1193.                 break;

  1194.             case JackParamChar:

  1195.                 sprintf(value_str, "%c", (char)value.c);

  1196.                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))

  1197.                 {

  1198.                     return false;

  1199.                 }

  1200.                 break;

  1201.             case JackParamString:

  1202.                 if (!jack_controller_settings_write_option(context, name, value.str, dbus_call_context_ptr))

  1203.                 {

  1204.                     return false;

  1205.                 }

  1206.                 break;

  1207.             case JackParamBool:

  1208.                 if (!jack_controller_settings_write_option(context, name, value.b ? "true" : "false", dbus_call_context_ptr))

  1209.                 {

  1210.                     return false;

  1211.                 }

  1212.                 break;

  1213.             default:

  1214.                 jack_error("parameter of unknown type %d", type);

  1215.             }

  1216.         }

  1217. 

  1218.         parameters_list = jack_slist_next(parameters_list);

  1219.     }

  1220. 

  1221.     return true;

  1222. }

  1223. 

  1224. bool

  1225. jack_controller_settings_save_engine_options(

  1226.     void *context,

  1227.     struct jack_controller *controller_ptr,

  1228.     void *dbus_call_context_ptr)

  1229. {

  1230.     if (controller_ptr->driver != NULL)

  1231.     {

  1232.         if (!jack_controller_settings_write_option(

  1233.                 context,

  1234.                 "driver",

  1235.                 jackctl_driver_get_name(controller_ptr->driver),

  1236.                 dbus_call_context_ptr))

  1237.         {

  1238.             return false;

  1239.         }

  1240.     }

  1241. 

  1242.     return jack_controller_settings_save_options(context, jackctl_server_get_parameters(controller_ptr->server), dbus_call_context_ptr);

  1243. }

  1244. 

  1245. bool

  1246. jack_controller_settings_save_driver_options(

  1247.     void *context,

  1248.     jackctl_driver_t *driver,

  1249.     void *dbus_call_context_ptr)

  1250. {

  1251.     return jack_controller_settings_save_options(context, jackctl_driver_get_parameters(driver), dbus_call_context_ptr);

  1252. }