dbus/controller.c

   1 /* -*- Mode: C ; c-basic-offset: 4 -*- */
   2 /*
   3     Copyright (C) 2007,2008 Nedko Arnaudov
   4     Copyright (C) 2007-2008 Juuso Alasuutari
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License.
   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 #if defined(HAVE_CONFIG_H)
  22 #include "config.h"
  23 #endif
  24
  25 #include <stdint.h>
  26 #include <string.h>
  27 #include <dbus/dbus.h>
  28
  29 #include "controller.h"
  30 #include "controller_internal.h"
  31 #include "xml.h"
  32
  33 struct jack_dbus_interface_descriptor * g_jackcontroller_interfaces[] =
  34 {
  35     &g_jack_controller_iface_introspectable,
  36     &g_jack_controller_iface_control,
  37     &g_jack_controller_iface_configure,
  38     &g_jack_controller_iface_patchbay,
  39     &g_jack_controller_iface_transport,
  40     NULL
  41 };
  42
  43 jackctl_driver_t *
  44 jack_controller_find_driver(
  45     jackctl_server_t *server,
  46     const char *driver_name)
  47 {
  48     const JSList * node_ptr;
  49
  50     node_ptr = jackctl_server_get_drivers_list(server);
  51
  52     while (node_ptr)
  53     {
  54         if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
  55         {
  56             return node_ptr->data;
  57         }
  58
  59         node_ptr = jack_slist_next(node_ptr);
  60     }
  61
  62     return NULL;
  63 }
  64
  65 jackctl_internal_t *
  66 jack_controller_find_internal(
  67     jackctl_server_t *server,
  68     const char *internal_name)
  69 {
  70     const JSList * node_ptr;
  71
  72     node_ptr = jackctl_server_get_internals_list(server);
  73
  74     while (node_ptr)
  75     {
  76         if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0)
  77         {
  78             return node_ptr->data;
  79         }
  80
  81         node_ptr = jack_slist_next(node_ptr);
  82     }
  83
  84     return NULL;
  85 }
  86
  87 jackctl_parameter_t *
  88 jack_controller_find_parameter(
  89     const JSList * parameters_list,
  90     const char * parameter_name)
  91 {
  92     while (parameters_list)
  93     {
  94         if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
  95         {
  96             return parameters_list->data;
  97         }
  98
  99         parameters_list = jack_slist_next(parameters_list);
 100     }
 101
 102     return NULL;
 103 }
 104
 105 bool
 106 jack_controller_select_driver(
 107     struct jack_controller * controller_ptr,
 108     const char * driver_name)
 109 {
 110     jackctl_driver_t *driver;
 111
 112     driver = jack_controller_find_driver(controller_ptr->server, driver_name);
 113     if (driver == NULL)
 114     {
 115         return false;
 116     }
 117
 118     jack_info("driver \"%s\" selected", driver_name);
 119
 120     controller_ptr->driver = driver;
 121     controller_ptr->driver_set = true;
 122
 123     return true;
 124 }
 125
 126 static
 127 int
 128 jack_controller_xrun(void * arg)
 129 {
 130         ((struct jack_controller *)arg)->xruns++;
 131
 132         return 0;
 133 }
 134
 135 bool
 136 jack_controller_start_server(
 137     struct jack_controller * controller_ptr,
 138     void *dbus_call_context_ptr)
 139 {
 140     int ret;
 141
 142     jack_info("Starting jack server...");
 143
 144     if (controller_ptr->started)
 145     {
 146         jack_info("Already started.");
 147         return TRUE;
 148     }
 149
 150     if (controller_ptr->driver == NULL)
 151     {
 152         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Select driver first!");
 153         goto fail;
 154     }
 155
 156     controller_ptr->xruns = 0;
 157
 158     if (!jackctl_server_start(
 159             controller_ptr->server,
 160             controller_ptr->driver))
 161     {
 162         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to start server");
 163         goto fail;
 164     }
 165
 166     controller_ptr->client = jack_client_open(
 167         "dbusapi",
 168         JackNoStartServer,
 169         NULL);
 170     if (controller_ptr->client == NULL)
 171     {
 172         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "failed to create dbusapi jack client");
 173
 174         goto fail_stop_server;
 175     }
 176
 177     ret = jack_set_xrun_callback(controller_ptr->client, jack_controller_xrun, controller_ptr);
 178     if (ret != 0)
 179     {
 180         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "failed to set xrun callback. error is %d", ret);
 181
 182         goto fail_close_client;
 183     }
 184
 185     if (!jack_controller_patchbay_init(controller_ptr))
 186     {
 187         jack_error("Failed to initialize patchbay district");
 188         goto fail_close_client;
 189     }
 190
 191     ret = jack_activate(controller_ptr->client);
 192     if (ret != 0)
 193     {
 194         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "failed to activate dbusapi jack client. error is %d", ret);
 195
 196         goto fail_patchbay_uninit;
 197     }
 198
 199     controller_ptr->started = true;
 200
 201     return TRUE;
 202
 203 fail_patchbay_uninit:
 204     jack_controller_patchbay_uninit(controller_ptr);
 205
 206 fail_close_client:
 207     ret = jack_client_close(controller_ptr->client);
 208     if (ret != 0)
 209     {
 210         jack_error("jack_client_close() failed with error %d", ret);
 211     }
 212
 213     controller_ptr->client = NULL;
 214
 215 fail_stop_server:
 216     if (!jackctl_server_stop(controller_ptr->server))
 217     {
 218         jack_error("failed to stop jack server");
 219     }
 220
 221 fail:
 222     return FALSE;
 223 }
 224
 225 bool
 226 jack_controller_stop_server(
 227     struct jack_controller * controller_ptr,
 228     void *dbus_call_context_ptr)
 229 {
 230     int ret;
 231
 232     jack_info("Stopping jack server...");
 233
 234     if (!controller_ptr->started)
 235     {
 236         jack_info("Already stopped.");
 237         return TRUE;
 238     }
 239
 240     ret = jack_deactivate(controller_ptr->client);
 241     if (ret != 0)
 242     {
 243         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "failed to deactivate dbusapi jack client. error is %d", ret);
 244     }
 245
 246     jack_controller_patchbay_uninit(controller_ptr);
 247
 248     ret = jack_client_close(controller_ptr->client);
 249     if (ret != 0)
 250     {
 251         jack_error("jack_client_close() failed with error %d", ret);
 252     }
 253
 254     controller_ptr->client = NULL;
 255
 256     if (!jackctl_server_stop(controller_ptr->server))
 257     {
 258         return FALSE;
 259     }
 260
 261     controller_ptr->started = false;
 262
 263     return TRUE;
 264 }
 265
 266 bool
 267 jack_controller_switch_master(
 268     struct jack_controller * controller_ptr,
 269     void *dbus_call_context_ptr)
 270 {
 271     if (!jackctl_server_switch_master(
 272             controller_ptr->server,
 273             controller_ptr->driver))
 274     {
 275         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to switch master");
 276         return FALSE;
 277     }
 278
 279     return TRUE;
 280 }
 281
 282 void *
 283 jack_controller_create(
 284         DBusConnection *connection)
 285 {
 286     struct jack_controller *controller_ptr;
 287     const JSList * node_ptr;
 288     const char ** driver_name_target;
 289     const char ** internal_name_target;
 290     JSList * drivers;
 291     JSList * internals;
 292     DBusObjectPathVTable vtable =
 293     {
 294         jack_dbus_message_handler_unregister,
 295         jack_dbus_message_handler,
 296         NULL
 297     };
 298
 299     controller_ptr = malloc(sizeof(struct jack_controller));
 300     if (!controller_ptr)
 301     {
 302         jack_error("Ran out of memory trying to allocate struct jack_controller");
 303         goto fail;
 304     }
 305
 306     controller_ptr->server = jackctl_server_create();
 307     if (controller_ptr->server == NULL)
 308     {
 309         jack_error("Failed to create server object");
 310         goto fail_free;
 311     }
 312
 313     controller_ptr->client = NULL;
 314     controller_ptr->started = false;
 315     controller_ptr->driver = NULL;
 316     controller_ptr->driver_set = false;
 317
 318     drivers = (JSList *)jackctl_server_get_drivers_list(controller_ptr->server);
 319     controller_ptr->drivers_count = jack_slist_length(drivers);
 320     controller_ptr->driver_names = malloc(controller_ptr->drivers_count * sizeof(const char *));
 321     if (controller_ptr->driver_names == NULL)
 322     {
 323         jack_error("Ran out of memory trying to allocate driver names array");
 324         goto fail_destroy_server;
 325     }
 326
 327     driver_name_target = controller_ptr->driver_names;
 328     node_ptr = jackctl_server_get_drivers_list(controller_ptr->server);
 329     while (node_ptr != NULL)
 330     {
 331         *driver_name_target = jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data);
 332
 333         /* select default driver */
 334         if (controller_ptr->driver == NULL && strcmp(*driver_name_target, DEFAULT_DRIVER) == 0)
 335         {
 336             controller_ptr->driver = (jackctl_driver_t *)node_ptr->data;
 337         }
 338
 339         node_ptr = jack_slist_next(node_ptr);
 340         driver_name_target++;
 341     }
 342
 343     internals = (JSList *)jackctl_server_get_internals_list(controller_ptr->server);
 344     controller_ptr->internals_count = jack_slist_length(internals);
 345     controller_ptr->internal_names = malloc(controller_ptr->internals_count * sizeof(const char *));
 346     if (controller_ptr->internal_names == NULL)
 347     {
 348         jack_error("Ran out of memory trying to allocate internals names array");
 349         goto fail_free_driver_names_array;
 350     }
 351
 352     internal_name_target = controller_ptr->internal_names;
 353     node_ptr = jackctl_server_get_internals_list(controller_ptr->server);
 354     while (node_ptr != NULL)
 355     {
 356         *internal_name_target = jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data);
 357         node_ptr = jack_slist_next(node_ptr);
 358         internal_name_target++;
 359     }
 360
 361     controller_ptr->dbus_descriptor.context = controller_ptr;
 362     controller_ptr->dbus_descriptor.interfaces = g_jackcontroller_interfaces;
 363
 364     if (!dbus_connection_register_object_path(
 365             connection,
 366             JACK_CONTROLLER_OBJECT_PATH,
 367             &vtable,
 368             &controller_ptr->dbus_descriptor))
 369     {
 370         jack_error("Ran out of memory trying to register D-Bus object path");
 371         goto fail_free_internal_names_array;
 372     }
 373
 374     jack_controller_settings_load(controller_ptr);
 375
 376     return controller_ptr;
 377
 378 fail_free_internal_names_array:
 379     free(controller_ptr->internal_names);
 380
 381 fail_free_driver_names_array:
 382     free(controller_ptr->driver_names);
 383
 384 fail_destroy_server:
 385     jackctl_server_destroy(controller_ptr->server);
 386
 387 fail_free:
 388     free(controller_ptr);
 389
 390 fail:
 391     return NULL;
 392 }
 393
 394 bool
 395 jack_controller_add_slave(
 396     struct jack_controller *controller_ptr,
 397     const char * driver_name)
 398 {
 399     jackctl_driver_t *driver;
 400
 401     driver = jack_controller_find_driver(controller_ptr->server, driver_name);
 402
 403     if (driver == NULL)
 404     {
 405         return false;
 406     }
 407
 408     jack_info("driver \"%s\" selected", driver_name);
 409
 410     return jackctl_server_add_slave(controller_ptr->server, driver);
 411 }
 412
 413 bool
 414 jack_controller_remove_slave(
 415     struct jack_controller *controller_ptr,
 416     const char * driver_name)
 417 {
 418     jackctl_driver_t *driver;
 419
 420     driver = jack_controller_find_driver(controller_ptr->server, driver_name);
 421
 422     if (driver == NULL)
 423     {
 424         return false;
 425     }
 426
 427     jack_info("driver \"%s\" selected", driver_name);
 428
 429     return jackctl_server_remove_slave(controller_ptr->server, driver);
 430 }
 431
 432 bool
 433 jack_controller_load_internal(
 434     struct jack_controller *controller_ptr,
 435     const char * internal_name)
 436 {
 437     jackctl_internal_t *internal;
 438
 439     internal = jack_controller_find_internal(controller_ptr->server, internal_name);
 440     if (internal == NULL)
 441     {
 442         return false;
 443     }
 444
 445     jack_info("internal \"%s\" selected", internal_name);
 446
 447     return jackctl_server_load_internal(controller_ptr->server, internal);
 448 }
 449
 450 bool
 451 jack_controller_unload_internal(
 452     struct jack_controller *controller_ptr,
 453     const char * internal_name)
 454 {
 455     jackctl_internal_t *internal;
 456
 457     internal = jack_controller_find_internal(controller_ptr->server, internal_name);
 458     if (internal == NULL)
 459     {
 460         return false;
 461     }
 462
 463     jack_info("internal \"%s\" selected", internal_name);
 464
 465     return jackctl_server_unload_internal(controller_ptr->server, internal);
 466 }
 467
 468 #define controller_ptr ((struct jack_controller *)context)
 469
 470 void
 471 jack_controller_destroy(
 472         void * context)
 473 {
 474     if (controller_ptr->started)
 475     {
 476         jack_controller_stop_server(controller_ptr, NULL);
 477     }
 478
 479     free(controller_ptr->driver_names);
 480     free(controller_ptr->internal_names);
 481
 482     jackctl_server_destroy(controller_ptr->server);
 483
 484     free(controller_ptr);
 485 }
 486