example-clients/server_control.cpp

   1 /*
   2         Copyright (C) 2008 Grame
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <stdio.h>
  20 #include <errno.h>
  21 #include <unistd.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <getopt.h>
  25 #include <jack/jack.h>
  26 #include <jack/control.h>
  27
  28 static jackctl_driver_t * jackctl_server_get_driver(jackctl_server_t *server, const char *driver_name)
  29 {
  30     const JSList * node_ptr = jackctl_server_get_drivers_list(server);
  31
  32     while (node_ptr) {
  33         if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0) {
  34             return (jackctl_driver_t *)node_ptr->data;
  35         }
  36         node_ptr = jack_slist_next(node_ptr);
  37     }
  38
  39     return NULL;
  40 }
  41
  42 static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
  43 {
  44     const JSList * node_ptr = jackctl_server_get_internals_list(server);
  45
  46     while (node_ptr) {
  47         if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
  48             return (jackctl_internal_t *)node_ptr->data;
  49         }
  50         node_ptr = jack_slist_next(node_ptr);
  51     }
  52
  53     return NULL;
  54 }
  55
  56 static jackctl_parameter_t *
  57 jackctl_get_parameter(
  58     const JSList * parameters_list,
  59     const char * parameter_name)
  60 {
  61     while (parameters_list)
  62     {
  63         if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
  64         {
  65             return (jackctl_parameter_t *)parameters_list->data;
  66         }
  67
  68         parameters_list = jack_slist_next(parameters_list);
  69     }
  70
  71     return NULL;
  72 }
  73
  74 static void print_value(union jackctl_parameter_value value, jackctl_param_type_t type)
  75 {
  76     switch (type) {
  77
  78         case JackParamInt:
  79             printf("parameter value = %d\n", value.i);
  80             break;
  81
  82          case JackParamUInt:
  83             printf("parameter value = %u\n", value.ui);
  84             break;
  85
  86          case JackParamChar:
  87             printf("parameter value = %c\n", value.c);
  88             break;
  89
  90          case JackParamString:
  91             printf("parameter value = %s\n", value.str);
  92             break;
  93
  94          case JackParamBool:
  95             printf("parameter value = %d\n", value.b);
  96             break;
  97      }
  98 }
  99
 100 static void print_parameters(const JSList * node_ptr)
 101 {
 102     while (node_ptr != NULL) {
 103         jackctl_parameter_t * parameter = (jackctl_parameter_t *)node_ptr->data;
 104         printf("\nparameter name = %s\n", jackctl_parameter_get_name(parameter));
 105         printf("parameter id = %c\n", jackctl_parameter_get_id(parameter));
 106         printf("parameter short decs = %s\n", jackctl_parameter_get_short_description(parameter));
 107         printf("parameter long decs = %s\n", jackctl_parameter_get_long_description(parameter));
 108         print_value(jackctl_parameter_get_default_value(parameter), jackctl_parameter_get_type(parameter));
 109         node_ptr = jack_slist_next(node_ptr);
 110     }
 111 }
 112
 113 static void print_driver(jackctl_driver_t * driver)
 114 {
 115     printf("\n--------------------------\n");
 116     printf("driver = %s\n", jackctl_driver_get_name(driver));
 117     printf("-------------------------- \n");
 118     print_parameters(jackctl_driver_get_parameters(driver));
 119 }
 120
 121 static void print_internal(jackctl_internal_t * internal)
 122 {
 123     printf("\n-------------------------- \n");
 124     printf("internal = %s\n", jackctl_internal_get_name(internal));
 125     printf("-------------------------- \n");
 126     print_parameters(jackctl_internal_get_parameters(internal));
 127 }
 128
 129 static void usage()
 130 {
 131         fprintf (stderr, "\n"
 132                                         "usage: jack_server_control \n"
 133                                         "              [ --driver OR -d driver_name ]\n"
 134                                         "              [ --client OR -c client_name ]\n"
 135         );
 136 }
 137
 138 int main(int argc, char *argv[])
 139 {
 140     jackctl_server_t * server;
 141     const JSList * parameters;
 142     const JSList * drivers;
 143     const JSList * internals;
 144     const JSList * node_ptr;
 145     sigset_t signals;
 146     int opt, option_index;
 147     const char* driver_name = "dummy";
 148     const char* client_name = "audioadapter";
 149
 150     const char *options = "d:c:";
 151         struct option long_options[] = {
 152                 {"driver", 1, 0, 'd'},
 153                 {"client", 1, 0, 'c'},
 154         };
 155
 156         while ((opt = getopt_long (argc, argv, options, long_options, &option_index)) != EOF) {
 157                 switch (opt) {
 158                         case 'd':
 159                                 driver_name = optarg;
 160                                 break;
 161                         case 'c':
 162                                 client_name = optarg;
 163                                 break;
 164             default:
 165                                 usage();
 166                 exit(0);
 167                 }
 168         }
 169
 170         server = jackctl_server_create(NULL, NULL);
 171     parameters = jackctl_server_get_parameters(server);
 172
 173     /*
 174     jackctl_parameter_t* param;
 175     union jackctl_parameter_value value;
 176     param = jackctl_get_parameter(parameters, "verbose");
 177     if (param != NULL) {
 178         value.b = true;
 179         jackctl_parameter_set_value(param, &value);
 180     }
 181     */
 182
 183     printf("\n========================== \n");
 184     printf("List of server parameters \n");
 185     printf("========================== \n");
 186
 187     print_parameters(parameters);
 188
 189     printf("\n========================== \n");
 190     printf("List of drivers \n");
 191     printf("========================== \n");
 192
 193     drivers = jackctl_server_get_drivers_list(server);
 194     node_ptr = drivers;
 195     while (node_ptr != NULL) {
 196         print_driver((jackctl_driver_t *)node_ptr->data);
 197         node_ptr = jack_slist_next(node_ptr);
 198     }
 199
 200     printf("\n========================== \n");
 201     printf("List of internal clients \n");
 202     printf("========================== \n");
 203
 204     internals = jackctl_server_get_internals_list(server);
 205     node_ptr = internals;
 206     while (node_ptr != NULL) {
 207         print_internal((jackctl_internal_t *)node_ptr->data);
 208         node_ptr = jack_slist_next(node_ptr);
 209     }
 210
 211     // No error checking in this simple example...
 212
 213     jackctl_server_open(server, jackctl_server_get_driver(server, driver_name));
 214     jackctl_server_start(server);
 215
 216     jackctl_server_load_internal(server, jackctl_server_get_internal(server, client_name));
 217
 218     /*
 219     // Switch master test
 220
 221     jackctl_driver_t* master;
 222
 223     usleep(5000000);
 224     printf("jackctl_server_load_master\n");
 225     master = jackctl_server_get_driver(server, "coreaudio");
 226     jackctl_server_switch_master(server, master);
 227
 228     usleep(5000000);
 229     printf("jackctl_server_load_master\n");
 230     master = jackctl_server_get_driver(server, "dummy");
 231     jackctl_server_switch_master(server, master);
 232
 233     */
 234
 235     signals = jackctl_setup_signals(0);
 236     jackctl_wait_signals(signals);
 237     jackctl_server_stop(server);
 238     jackctl_server_close(server);
 239     jackctl_server_destroy(server);
 240     return 0;
 241 }