proxies/jack_proxy.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains helper functionality for accessing JACK through D-Bus
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 //#define LADISH_DEBUG
  28
  29 #include "jack_proxy.h"
  30
  31 jack_proxy_callback_server_started g_on_server_started;
  32 jack_proxy_callback_server_stopped g_on_server_stopped;
  33 jack_proxy_callback_server_appeared g_on_server_appeared;
  34 jack_proxy_callback_server_disappeared g_on_server_disappeared;
  35
  36 static void on_jack_server_started(void * context, DBusMessage * message_ptr)
  37 {
  38   log_debug("JACK server start signal received.");
  39   if (g_on_server_started != NULL)
  40   {
  41     g_on_server_started();
  42   }
  43 }
  44
  45 static void on_jack_server_stopped(void * context, DBusMessage * message_ptr)
  46 {
  47   log_debug("JACK server stop signal received.");
  48   if (g_on_server_stopped != NULL)
  49   {
  50     g_on_server_stopped();
  51   }
  52 }
  53
  54 static void on_jack_life_status_changed(bool appeared)
  55 {
  56   if (appeared)
  57   {
  58     log_debug("JACK serivce appeared");
  59     if (g_on_server_appeared != NULL)
  60     {
  61       g_on_server_appeared();
  62     }
  63   }
  64   else
  65   {
  66     log_debug("JACK serivce disappeared");
  67     if (g_on_server_disappeared != NULL)
  68     {
  69       g_on_server_disappeared();
  70     }
  71   }
  72 }
  73
  74 /* this must be static because it is referenced by the
  75  * dbus helper layer when hooks are active */
  76 static struct dbus_signal_hook g_control_signal_hooks[] =
  77 {
  78   {"ServerStarted", on_jack_server_started},
  79   {"ServerStopped", on_jack_server_stopped},
  80   {NULL, NULL}
  81 };
  82
  83 bool
  84 jack_proxy_init(
  85   jack_proxy_callback_server_started server_started,
  86   jack_proxy_callback_server_stopped server_stopped,
  87   jack_proxy_callback_server_appeared server_appeared,
  88   jack_proxy_callback_server_disappeared server_disappeared)
  89 {
  90   g_on_server_started = server_started;
  91   g_on_server_stopped = server_stopped;
  92   g_on_server_appeared = server_appeared;
  93   g_on_server_disappeared = server_disappeared;
  94
  95   if (!dbus_register_service_lifetime_hook(g_dbus_connection, JACKDBUS_SERVICE_NAME, on_jack_life_status_changed))
  96   {
  97     log_error("dbus_register_service_lifetime_hook() failed for jackdbus service");
  98     return false;
  99   }
 100
 101   if (!dbus_register_object_signal_hooks(
 102         g_dbus_connection,
 103         JACKDBUS_SERVICE_NAME,
 104         JACKDBUS_OBJECT_PATH,
 105         JACKDBUS_IFACE_CONTROL,
 106         NULL,
 107         g_control_signal_hooks))
 108   {
 109     dbus_unregister_service_lifetime_hook(g_dbus_connection, JACKDBUS_SERVICE_NAME);
 110     log_error("dbus_register_object_signal_hooks() failed for jackdbus control interface");
 111     return false;
 112   }
 113
 114   {
 115     bool started;
 116
 117     if (jack_proxy_is_started(&started))
 118     {
 119       if (g_on_server_appeared != NULL)
 120       {
 121         g_on_server_appeared();
 122       }
 123
 124       if (g_on_server_started != NULL && started)
 125       {
 126         g_on_server_started();
 127       }
 128     }
 129   }
 130
 131   return true;
 132 }
 133
 134 void
 135 jack_proxy_uninit(
 136   void)
 137 {
 138   dbus_unregister_object_signal_hooks(g_dbus_connection, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL);
 139   dbus_unregister_service_lifetime_hook(g_dbus_connection, JACKDBUS_SERVICE_NAME);
 140 }
 141
 142 bool
 143 jack_proxy_is_started(
 144   bool * started_ptr)
 145 {
 146   dbus_bool_t started;
 147
 148   if (!dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "IsStarted", "", "b", &started))
 149   {
 150     return false;
 151   }
 152
 153   *started_ptr = started;
 154   return true;
 155 }
 156
 157 bool
 158 jack_proxy_connect_ports(
 159   uint64_t port1_id,
 160   uint64_t port2_id)
 161 {
 162   return false;
 163 }
 164
 165 static
 166 bool
 167 add_address(
 168   DBusMessageIter * iter_ptr,
 169   const char * address)
 170 {
 171   DBusMessageIter array_iter;
 172   const char * component;
 173
 174   if (!dbus_message_iter_open_container(iter_ptr, DBUS_TYPE_ARRAY, "s", &array_iter))
 175   {
 176     log_error("dbus_message_iter_open_container() failed.");
 177     return false;
 178   }
 179
 180   if (address != NULL)
 181   {
 182     component = address;
 183     while (*component != 0)
 184     {
 185       if (!dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING, &component))
 186       {
 187         log_error("dbus_message_iter_append_basic() failed.");
 188         return false;
 189       }
 190
 191       component += strlen(component) + 1;
 192     }
 193   }
 194
 195   dbus_message_iter_close_container(iter_ptr, &array_iter);
 196
 197   return true;
 198 }
 199
 200 bool
 201 jack_proxy_read_conf_container(
 202   const char * address,
 203   void * callback_context,
 204   bool (* callback)(void * context, bool leaf, const char * address, char * child))
 205 {
 206   DBusMessage * request_ptr;
 207   DBusMessage * reply_ptr;
 208   DBusMessageIter top_iter;
 209   DBusMessageIter array_iter;
 210   const char * reply_signature;
 211   dbus_bool_t leaf;           /* Whether children are parameters (true) or containers (false) */
 212   char * child;
 213
 214   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "ReadContainer");
 215   if (request_ptr == NULL)
 216   {
 217     log_error("dbus_message_new_method_call() failed.");
 218     return false;
 219   }
 220
 221   dbus_message_iter_init_append(request_ptr, &top_iter);
 222
 223   if (!add_address(&top_iter, address))
 224   {
 225     dbus_message_unref(request_ptr);
 226     return false;
 227   }
 228
 229   reply_ptr = dbus_call_raw(0, request_ptr);
 230   dbus_message_unref(request_ptr);
 231   if (reply_ptr == NULL)
 232   {
 233     return false;
 234   }
 235
 236   reply_signature = dbus_message_get_signature(reply_ptr);
 237
 238   if (strcmp(reply_signature, "bas") != 0)
 239   {
 240     log_error("ReadContainer() reply signature mismatch. '%s'", reply_signature);
 241     dbus_message_unref(reply_ptr);
 242     return false;
 243   }
 244
 245   dbus_message_iter_init(reply_ptr, &top_iter);
 246
 247   dbus_message_iter_get_basic(&top_iter, &leaf);
 248   dbus_message_iter_next(&top_iter);
 249
 250   dbus_message_iter_recurse(&top_iter, &array_iter);
 251
 252   while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
 253   {
 254     dbus_message_iter_get_basic(&array_iter, &child);
 255
 256     if (!callback(callback_context, leaf, address, child))
 257     {
 258       break;
 259     }
 260
 261     dbus_message_iter_next(&array_iter);
 262   }
 263
 264   dbus_message_unref(reply_ptr);
 265
 266   return true;
 267 }
 268
 269 bool
 270 get_variant(
 271   DBusMessageIter * iter_ptr,
 272   struct jack_parameter_variant * parameter_ptr)
 273 {
 274   DBusMessageIter variant_iter;
 275   int type;
 276   dbus_bool_t boolean;
 277   dbus_int32_t int32;
 278   dbus_uint32_t uint32;
 279   char * string;
 280
 281   dbus_message_iter_recurse(iter_ptr, &variant_iter);
 282   log_debug("variant signature: '%s'", dbus_message_iter_get_signature(&variant_iter));
 283
 284   type = dbus_message_iter_get_arg_type(&variant_iter);
 285   switch (type)
 286   {
 287   case DBUS_TYPE_INT32:
 288     dbus_message_iter_get_basic(&variant_iter, &int32);
 289     parameter_ptr->value.int32 = int32;
 290     parameter_ptr->type = jack_int32;
 291     return true;
 292   case DBUS_TYPE_UINT32:
 293     dbus_message_iter_get_basic(&variant_iter, &uint32);
 294     parameter_ptr->value.uint32 = uint32;
 295     parameter_ptr->type = jack_uint32;
 296     return true;
 297   case DBUS_TYPE_BYTE:
 298     dbus_message_iter_get_basic(&variant_iter, &parameter_ptr->value.byte);
 299     parameter_ptr->type = jack_byte;
 300     return true;
 301   case DBUS_TYPE_STRING:
 302     dbus_message_iter_get_basic(&variant_iter, &string);
 303     string = strdup(string);
 304     if (string == NULL)
 305     {
 306       log_error("strdup failed.");
 307       return false;
 308     }
 309
 310     parameter_ptr->value.string = string;
 311     parameter_ptr->type = jack_string;
 312     return true;
 313   case DBUS_TYPE_BOOLEAN:
 314     dbus_message_iter_get_basic(&variant_iter, &boolean);
 315     parameter_ptr->value.boolean = boolean;
 316     parameter_ptr->type = jack_boolean;
 317     return true;
 318   }
 319
 320   log_error("Unknown D-Bus parameter type %i", (int)type);
 321   return false;
 322 }
 323
 324 bool
 325 jack_proxy_get_parameter_value(
 326   const char * address,
 327   bool * is_set_ptr,
 328   struct jack_parameter_variant * parameter_ptr)
 329 {
 330   DBusMessage * request_ptr;
 331   DBusMessage * reply_ptr;
 332   DBusMessageIter top_iter;
 333   const char * reply_signature;
 334   dbus_bool_t is_set;
 335   struct jack_parameter_variant default_value;
 336
 337   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "GetParameterValue");
 338   if (request_ptr == NULL)
 339   {
 340     log_error("dbus_message_new_method_call() failed.");
 341     return false;
 342   }
 343
 344   dbus_message_iter_init_append(request_ptr, &top_iter);
 345
 346   if (!add_address(&top_iter, address))
 347   {
 348     dbus_message_unref(request_ptr);
 349     return false;
 350   }
 351
 352   reply_ptr = dbus_call_raw(0, request_ptr);
 353   dbus_message_unref(request_ptr);
 354   if (reply_ptr == NULL)
 355   {
 356     return false;
 357   }
 358
 359   reply_signature = dbus_message_get_signature(reply_ptr);
 360
 361   if (strcmp(reply_signature, "bvv") != 0)
 362   {
 363     log_error("GetParameterValue() reply signature mismatch. '%s'", reply_signature);
 364     dbus_message_unref(reply_ptr);
 365     return false;
 366   }
 367
 368   dbus_message_iter_init(reply_ptr, &top_iter);
 369
 370   dbus_message_iter_get_basic(&top_iter, &is_set);
 371   dbus_message_iter_next(&top_iter);
 372
 373   if (!get_variant(&top_iter, &default_value))
 374   {
 375     dbus_message_unref(reply_ptr);
 376     return false;
 377   }
 378
 379   if (default_value.type == jack_string)
 380   {
 381     free(default_value.value.string);
 382   }
 383
 384   dbus_message_iter_next(&top_iter);
 385
 386   if (!get_variant(&top_iter, parameter_ptr))
 387   {
 388     dbus_message_unref(reply_ptr);
 389     return false;
 390   }
 391
 392   dbus_message_unref(reply_ptr);
 393
 394   *is_set_ptr = is_set;
 395
 396   return true;
 397 }
 398
 399 bool
 400 jack_proxy_set_parameter_value(
 401   const char * address,
 402   const struct jack_parameter_variant * parameter_ptr)
 403 {
 404   DBusMessage * request_ptr;
 405   DBusMessage * reply_ptr;
 406   DBusMessageIter top_iter;
 407   const char * reply_signature;
 408   int type;
 409   const void * value_ptr;
 410   dbus_bool_t boolean;
 411
 412   switch (parameter_ptr->type)
 413   {
 414   case jack_int32:
 415     type = DBUS_TYPE_INT32;
 416     value_ptr = &parameter_ptr->value.int32;
 417     break;
 418   case jack_uint32:
 419     type = DBUS_TYPE_UINT32;
 420     value_ptr = &parameter_ptr->value.uint32;
 421     break;
 422   case jack_byte:
 423     type = DBUS_TYPE_BYTE;
 424     value_ptr = &parameter_ptr->value.byte;
 425     break;
 426   case jack_string:
 427     type = DBUS_TYPE_STRING;
 428     value_ptr = &parameter_ptr->value.string;
 429     break;
 430   case jack_boolean:
 431     type = DBUS_TYPE_BOOLEAN;
 432     boolean = parameter_ptr->value.boolean;
 433     value_ptr = &boolean;
 434     break;
 435   default:
 436     log_error("Unknown jack parameter type %i", (int)parameter_ptr->type);
 437     return false;
 438   }
 439
 440   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "SetParameterValue");
 441   if (request_ptr == NULL)
 442   {
 443     log_error("dbus_message_new_method_call() failed.");
 444     return false;
 445   }
 446
 447   dbus_message_iter_init_append(request_ptr, &top_iter);
 448
 449   if (!add_address(&top_iter, address))
 450   {
 451     dbus_message_unref(request_ptr);
 452     return false;
 453   }
 454
 455   if (!dbus_iter_append_variant(&top_iter, type, value_ptr))
 456   {
 457     dbus_message_unref(request_ptr);
 458     return false;
 459   }
 460
 461   reply_ptr = dbus_call_raw(0, request_ptr);
 462   dbus_message_unref(request_ptr);
 463   if (reply_ptr == NULL)
 464   {
 465     return false;
 466   }
 467
 468   reply_signature = dbus_message_get_signature(reply_ptr);
 469
 470   dbus_message_unref(reply_ptr);
 471
 472   if (strcmp(reply_signature, "") != 0)
 473   {
 474     log_error("SetParameterValue() reply signature mismatch. '%s'", reply_signature);
 475     return false;
 476   }
 477
 478   return true;
 479 }
 480
 481 bool
 482 jack_proxy_reset_parameter_value(
 483   const char * address)
 484 {
 485   DBusMessage * request_ptr;
 486   DBusMessage * reply_ptr;
 487   DBusMessageIter top_iter;
 488   const char * reply_signature;
 489
 490   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "ResetParameterValue");
 491   if (request_ptr == NULL)
 492   {
 493     log_error("dbus_message_new_method_call() failed.");
 494     return false;
 495   }
 496
 497   dbus_message_iter_init_append(request_ptr, &top_iter);
 498
 499   if (!add_address(&top_iter, address))
 500   {
 501     dbus_message_unref(request_ptr);
 502     return false;
 503   }
 504
 505   reply_ptr = dbus_call_raw(0, request_ptr);
 506   dbus_message_unref(request_ptr);
 507   if (reply_ptr == NULL)
 508   {
 509     return false;
 510   }
 511
 512   reply_signature = dbus_message_get_signature(reply_ptr);
 513
 514   dbus_message_unref(reply_ptr);
 515
 516   if (strcmp(reply_signature, "") != 0)
 517   {
 518     log_error("ResetParameterValue() reply signature mismatch. '%s'", reply_signature);
 519     return false;
 520   }
 521
 522   return true;
 523 }
 524
 525 bool jack_proxy_start_server(void)
 526 {
 527   return dbus_call(7000, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "StartServer", "", "");
 528 }
 529
 530 bool jack_proxy_stop_server(void)
 531 {
 532   return dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "StopServer", "", "");
 533 }
 534
 535 bool jack_proxy_is_realtime(bool * realtime_ptr)
 536 {
 537   dbus_bool_t realtime;
 538
 539   if (!dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "IsStarted", "", "b", &realtime))
 540   {
 541     return false;
 542   }
 543
 544   *realtime_ptr = realtime;
 545   return true;
 546 }
 547
 548 bool jack_proxy_sample_rate(uint32_t * sample_rate_ptr)
 549 {
 550   return dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetSampleRate", "", "u", sample_rate_ptr);
 551 }
 552
 553 bool jack_proxy_get_xruns(uint32_t * xruns_ptr)
 554 {
 555   return dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetXruns", "", "u", xruns_ptr);
 556 }
 557
 558 bool jack_proxy_get_dsp_load(double * dsp_load_ptr)
 559 {
 560   return dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetLoad", "", "d", dsp_load_ptr);
 561 }
 562
 563 bool jack_proxy_get_buffer_size(uint32_t * size_ptr)
 564 {
 565   return dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetBufferSize", "", "u", size_ptr);
 566 }
 567
 568 bool jack_proxy_set_buffer_size(uint32_t size)
 569 {
 570   return dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "SetBufferSize", "u", &size, "");
 571 }
 572
 573 bool jack_proxy_reset_xruns(void)
 574 {
 575   return dbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "ResetXruns", "", "");
 576 }
 577
 578 static
 579 bool
 580 reset_callback(
 581   void * context,
 582   bool leaf,
 583   const char * address,
 584   char * child)
 585 {
 586   const char * component;
 587   char * dst;
 588   size_t len;
 589
 590   component = address;
 591   while (*component != 0)
 592   {
 593     component += strlen(component) + 1;
 594   }
 595
 596   /* address always is same buffer as the one in the jack_reset_all_params() stack */
 597   dst = (char *)component;
 598
 599   len = strlen(child) + 1;
 600   memcpy(dst, child, len);
 601   dst[len] = 0;
 602
 603   if (leaf)
 604   {
 605     if (!jack_proxy_reset_parameter_value(address))
 606     {
 607       log_error("cannot reset value of parameter");
 608       return false;
 609     }
 610   }
 611   else
 612   {
 613     if (!jack_proxy_read_conf_container(address, context, reset_callback))
 614     {
 615       log_error("cannot read container");
 616       return false;
 617     }
 618   }
 619
 620   *dst = 0;
 621
 622   return true;
 623 }
 624
 625 bool jack_reset_all_params(void)
 626 {
 627   char address[1024] = "";
 628
 629   return jack_proxy_read_conf_container(address, NULL, reset_callback);
 630 }