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 #if 0
  57 static jackctl_parameter_t *
  58 jackctl_get_parameter(
  59     const JSList * parameters_list,
  60     const char * parameter_name)
  61 {
  62     while (parameters_list)
  63     {
  64         if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
  65         {
  66             return (jackctl_parameter_t *)parameters_list->data;
  67         }
  68
  69         parameters_list = jack_slist_next(parameters_list);
  70     }
  71
  72     return NULL;
  73 }
  74 #endif
  75
  76 static void print_value(union jackctl_parameter_value value, jackctl_param_type_t type)
  77 {
  78     switch (type) {
  79
  80         case JackParamInt:
  81             printf("parameter value = %d\n", value.i);
  82             break;
  83
  84          case JackParamUInt:
  85             printf("parameter value = %u\n", value.ui);
  86             break;
  87
  88          case JackParamChar:
  89             printf("parameter value = %c\n", value.c);
  90             break;
  91
  92          case JackParamString:
  93             printf("parameter value = %s\n", value.str);
  94             break;
  95
  96          case JackParamBool:
  97             printf("parameter value = %d\n", value.b);
  98             break;
  99      }
 100 }
 101
 102 static void print_parameters(const JSList * node_ptr)
 103 {
 104     while (node_ptr != NULL) {
 105         jackctl_parameter_t * parameter = (jackctl_parameter_t *)node_ptr->data;
 106         printf("\nparameter name = %s\n", jackctl_parameter_get_name(parameter));
 107         printf("parameter id = %c\n", jackctl_parameter_get_id(parameter));
 108         printf("parameter short decs = %s\n", jackctl_parameter_get_short_description(parameter));
 109         printf("parameter long decs = %s\n", jackctl_parameter_get_long_description(parameter));
 110         print_value(jackctl_parameter_get_default_value(parameter), jackctl_parameter_get_type(parameter));
 111         node_ptr = jack_slist_next(node_ptr);
 112     }
 113 }
 114
 115 static void print_driver(jackctl_driver_t * driver)
 116 {
 117     printf("\n--------------------------\n");
 118     printf("driver = %s\n", jackctl_driver_get_name(driver));
 119     printf("-------------------------- \n");
 120     print_parameters(jackctl_driver_get_parameters(driver));
 121 }
 122
 123 static void print_internal(jackctl_internal_t * internal)
 124 {
 125     printf("\n-------------------------- \n");
 126     printf("internal = %s\n", jackctl_internal_get_name(internal));
 127     printf("-------------------------- \n");
 128     print_parameters(jackctl_internal_get_parameters(internal));
 129 }
 130
 131 static void usage()
 132 {
 133         fprintf (stderr, "\n"
 134                                         "usage: jack_server_control \n"
 135                                         "              [ --driver OR -d driver_name ]\n"
 136                                         "              [ --client OR -c client_name ]\n"
 137         );
 138 }
 139
 140 int main(int argc, char *argv[])
 141 {
 142     jackctl_server_t * server;
 143     const JSList * parameters;
 144     const JSList * drivers;
 145     const JSList * internals;
 146     const JSList * node_ptr;
 147     jackctl_sigmask_t * sigmask;
 148     int opt, option_index;
 149     const char* driver_name = "dummy";
 150     const char* client_name = "audioadapter";
 151
 152     const char *options = "d:c:";
 153         struct option long_options[] = {
 154                 {"driver", 1, 0, 'd'},
 155                 {"client", 1, 0, 'c'},
 156         {0, 0, 0, 0}
 157         };
 158
 159         while ((opt = getopt_long (argc, argv, options, long_options, &option_index)) != -1) {
 160                 switch (opt) {
 161                         case 'd':
 162                                 driver_name = optarg;
 163                                 break;
 164                         case 'c':
 165                                 client_name = optarg;
 166                                 break;
 167             default:
 168                                 usage();
 169                 exit(0);
 170                 }
 171         }
 172
 173         server = jackctl_server_create(NULL, NULL);
 174     parameters = jackctl_server_get_parameters(server);
 175
 176     /*
 177     jackctl_parameter_t* param;
 178     union jackctl_parameter_value value;
 179     param = jackctl_get_parameter(parameters, "verbose");
 180     if (param != NULL) {
 181         value.b = true;
 182         jackctl_parameter_set_value(param, &value);
 183     }
 184     */
 185
 186     printf("\n========================== \n");
 187     printf("List of server parameters \n");
 188     printf("========================== \n");
 189
 190     print_parameters(parameters);
 191
 192     printf("\n========================== \n");
 193     printf("List of drivers \n");
 194     printf("========================== \n");
 195
 196     drivers = jackctl_server_get_drivers_list(server);
 197     node_ptr = drivers;
 198     while (node_ptr != NULL) {
 199         print_driver((jackctl_driver_t *)node_ptr->data);
 200         node_ptr = jack_slist_next(node_ptr);
 201     }
 202
 203     printf("\n========================== \n");
 204     printf("List of internal clients \n");
 205     printf("========================== \n");
 206
 207     internals = jackctl_server_get_internals_list(server);
 208     node_ptr = internals;
 209     while (node_ptr != NULL) {
 210         print_internal((jackctl_internal_t *)node_ptr->data);
 211         node_ptr = jack_slist_next(node_ptr);
 212     }
 213
 214     // No error checking in this simple example...
 215
 216     jackctl_server_open(server, jackctl_server_get_driver(server, driver_name));
 217     jackctl_server_start(server);
 218
 219     jackctl_server_load_internal(server, jackctl_server_get_internal(server, client_name));
 220
 221     /*
 222     // Switch master test
 223
 224     jackctl_driver_t* master;
 225
 226     usleep(5000000);
 227     printf("jackctl_server_load_master\n");
 228     master = jackctl_server_get_driver(server, "coreaudio");
 229     jackctl_server_switch_master(server, master);
 230
 231     usleep(5000000);
 232     printf("jackctl_server_load_master\n");
 233     master = jackctl_server_get_driver(server, "dummy");
 234     jackctl_server_switch_master(server, master);
 235
 236     */
 237
 238     sigmask = jackctl_setup_signals(0);
 239     jackctl_wait_signals(sigmask);
 240     jackctl_server_stop(server);
 241     jackctl_server_close(server);
 242     jackctl_server_destroy(server);
 243     return 0;
 244 }