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(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   // send message and get a handle for a reply
 230   reply_ptr = dbus_connection_send_with_reply_and_block(
 231     g_dbus_connection,
 232     request_ptr,
 233     DBUS_CALL_DEFAULT_TIMEOUT,
 234     &g_dbus_error);
 235
 236   dbus_message_unref(request_ptr);
 237
 238   if (reply_ptr == NULL)
 239   {
 240     log_error("no reply from JACK server, error is '%s'", g_dbus_error.message);
 241     dbus_error_free(&g_dbus_error);
 242     return false;
 243   }
 244
 245   reply_signature = dbus_message_get_signature(reply_ptr);
 246
 247   if (strcmp(reply_signature, "bas") != 0)
 248   {
 249     log_error("ReadContainer() reply signature mismatch. '%s'", reply_signature);
 250     dbus_message_unref(reply_ptr);
 251     return false;
 252   }
 253
 254   dbus_message_iter_init(reply_ptr, &top_iter);
 255
 256   dbus_message_iter_get_basic(&top_iter, &leaf);
 257   dbus_message_iter_next(&top_iter);
 258
 259   dbus_message_iter_recurse(&top_iter, &array_iter);
 260
 261   while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
 262   {
 263     dbus_message_iter_get_basic(&array_iter, &child);
 264
 265     if (!callback(callback_context, leaf, address, child))
 266     {
 267       break;
 268     }
 269
 270     dbus_message_iter_next(&array_iter);
 271   }
 272
 273   dbus_message_unref(reply_ptr);
 274
 275   return true;
 276 }
 277
 278 bool
 279 get_variant(
 280   DBusMessageIter * iter_ptr,
 281   struct jack_parameter_variant * parameter_ptr)
 282 {
 283   DBusMessageIter variant_iter;
 284   int type;
 285   dbus_bool_t boolean;
 286   dbus_int32_t int32;
 287   dbus_uint32_t uint32;
 288   char * string;
 289
 290   dbus_message_iter_recurse(iter_ptr, &variant_iter);
 291   log_debug("variant signature: '%s'", dbus_message_iter_get_signature(&variant_iter));
 292
 293   type = dbus_message_iter_get_arg_type(&variant_iter);
 294   switch (type)
 295   {
 296   case DBUS_TYPE_INT32:
 297     dbus_message_iter_get_basic(&variant_iter, &int32);
 298     parameter_ptr->value.int32 = int32;
 299     parameter_ptr->type = jack_int32;
 300     return true;
 301   case DBUS_TYPE_UINT32:
 302     dbus_message_iter_get_basic(&variant_iter, &uint32);
 303     parameter_ptr->value.uint32 = uint32;
 304     parameter_ptr->type = jack_uint32;
 305     return true;
 306   case DBUS_TYPE_BYTE:
 307     dbus_message_iter_get_basic(&variant_iter, &parameter_ptr->value.byte);
 308     parameter_ptr->type = jack_byte;
 309     return true;
 310   case DBUS_TYPE_STRING:
 311     dbus_message_iter_get_basic(&variant_iter, &string);
 312     string = strdup(string);
 313     if (string == NULL)
 314     {
 315       log_error("strdup failed.");
 316       return false;
 317     }
 318
 319     parameter_ptr->value.string = string;
 320     parameter_ptr->type = jack_string;
 321     return true;
 322   case DBUS_TYPE_BOOLEAN:
 323     dbus_message_iter_get_basic(&variant_iter, &boolean);
 324     parameter_ptr->value.boolean = boolean;
 325     parameter_ptr->type = jack_boolean;
 326     return true;
 327   }
 328
 329   log_error("Unknown D-Bus parameter type %i", (int)type);
 330   return false;
 331 }
 332
 333 bool
 334 jack_proxy_get_parameter_value(
 335   const char * address,
 336   bool * is_set_ptr,
 337   struct jack_parameter_variant * parameter_ptr)
 338 {
 339   DBusMessage * request_ptr;
 340   DBusMessage * reply_ptr;
 341   DBusMessageIter top_iter;
 342   const char * reply_signature;
 343   dbus_bool_t is_set;
 344   struct jack_parameter_variant default_value;
 345
 346   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "GetParameterValue");
 347   if (request_ptr == NULL)
 348   {
 349     log_error("dbus_message_new_method_call() failed.");
 350     return false;
 351   }
 352
 353   dbus_message_iter_init_append(request_ptr, &top_iter);
 354
 355   if (!add_address(&top_iter, address))
 356   {
 357     dbus_message_unref(request_ptr);
 358     return false;
 359   }
 360
 361   // send message and get a handle for a reply
 362   reply_ptr = dbus_connection_send_with_reply_and_block(
 363     g_dbus_connection,
 364     request_ptr,
 365     DBUS_CALL_DEFAULT_TIMEOUT,
 366     &g_dbus_error);
 367
 368   dbus_message_unref(request_ptr);
 369
 370   if (reply_ptr == NULL)
 371   {
 372     log_error("no reply from JACK server, error is '%s'", g_dbus_error.message);
 373     dbus_error_free(&g_dbus_error);
 374     return false;
 375   }
 376
 377   reply_signature = dbus_message_get_signature(reply_ptr);
 378
 379   if (strcmp(reply_signature, "bvv") != 0)
 380   {
 381     log_error("GetParameterValue() reply signature mismatch. '%s'", reply_signature);
 382     dbus_message_unref(reply_ptr);
 383     return false;
 384   }
 385
 386   dbus_message_iter_init(reply_ptr, &top_iter);
 387
 388   dbus_message_iter_get_basic(&top_iter, &is_set);
 389   dbus_message_iter_next(&top_iter);
 390
 391   if (!get_variant(&top_iter, &default_value))
 392   {
 393     dbus_message_unref(reply_ptr);
 394     return false;
 395   }
 396
 397   if (default_value.type == jack_string)
 398   {
 399     free(default_value.value.string);
 400   }
 401
 402   dbus_message_iter_next(&top_iter);
 403
 404   if (!get_variant(&top_iter, parameter_ptr))
 405   {
 406     dbus_message_unref(reply_ptr);
 407     return false;
 408   }
 409
 410   dbus_message_unref(reply_ptr);
 411
 412   *is_set_ptr = is_set;
 413
 414   return true;
 415 }
 416
 417 bool
 418 jack_proxy_set_parameter_value(
 419   const char * address,
 420   const struct jack_parameter_variant * parameter_ptr)
 421 {
 422   DBusMessage * request_ptr;
 423   DBusMessage * reply_ptr;
 424   DBusMessageIter top_iter;
 425   const char * reply_signature;
 426   int type;
 427   const void * value_ptr;
 428   dbus_bool_t boolean;
 429
 430   switch (parameter_ptr->type)
 431   {
 432   case jack_int32:
 433     type = DBUS_TYPE_INT32;
 434     value_ptr = &parameter_ptr->value.int32;
 435     break;
 436   case jack_uint32:
 437     type = DBUS_TYPE_UINT32;
 438     value_ptr = &parameter_ptr->value.uint32;
 439     break;
 440   case jack_byte:
 441     type = DBUS_TYPE_BYTE;
 442     value_ptr = &parameter_ptr->value.byte;
 443     break;
 444   case jack_string:
 445     type = DBUS_TYPE_STRING;
 446     value_ptr = &parameter_ptr->value.string;
 447     break;
 448   case jack_boolean:
 449     type = DBUS_TYPE_BOOLEAN;
 450     boolean = parameter_ptr->value.boolean;
 451     value_ptr = &boolean;
 452     break;
 453   default:
 454     log_error("Unknown jack parameter type %i", (int)parameter_ptr->type);
 455     return false;
 456   }
 457
 458   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "SetParameterValue");
 459   if (request_ptr == NULL)
 460   {
 461     log_error("dbus_message_new_method_call() failed.");
 462     return false;
 463   }
 464
 465   dbus_message_iter_init_append(request_ptr, &top_iter);
 466
 467   if (!add_address(&top_iter, address))
 468   {
 469     dbus_message_unref(request_ptr);
 470     return false;
 471   }
 472
 473   if (!dbus_iter_append_variant(&top_iter, type, value_ptr))
 474   {
 475     dbus_message_unref(request_ptr);
 476     return false;
 477   }
 478
 479   // send message and get a handle for a reply
 480   reply_ptr = dbus_connection_send_with_reply_and_block(
 481     g_dbus_connection,
 482     request_ptr,
 483     DBUS_CALL_DEFAULT_TIMEOUT,
 484     &g_dbus_error);
 485
 486   dbus_message_unref(request_ptr);
 487
 488   if (reply_ptr == NULL)
 489   {
 490     log_error("no reply from JACK server, error is '%s'", g_dbus_error.message);
 491     dbus_error_free(&g_dbus_error);
 492     return false;
 493   }
 494
 495   reply_signature = dbus_message_get_signature(reply_ptr);
 496
 497   dbus_message_unref(reply_ptr);
 498
 499   if (strcmp(reply_signature, "") != 0)
 500   {
 501     log_error("SetParameterValue() reply signature mismatch. '%s'", reply_signature);
 502     return false;
 503   }
 504
 505   return true;
 506 }
 507
 508 bool
 509 jack_proxy_reset_parameter_value(
 510   const char * address)
 511 {
 512   DBusMessage * request_ptr;
 513   DBusMessage * reply_ptr;
 514   DBusMessageIter top_iter;
 515   const char * reply_signature;
 516
 517   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "ResetParameterValue");
 518   if (request_ptr == NULL)
 519   {
 520     log_error("dbus_message_new_method_call() failed.");
 521     return false;
 522   }
 523
 524   dbus_message_iter_init_append(request_ptr, &top_iter);
 525
 526   if (!add_address(&top_iter, address))
 527   {
 528     dbus_message_unref(request_ptr);
 529     return false;
 530   }
 531
 532   // send message and get a handle for a reply
 533   reply_ptr = dbus_connection_send_with_reply_and_block(
 534     g_dbus_connection,
 535     request_ptr,
 536     DBUS_CALL_DEFAULT_TIMEOUT,
 537     &g_dbus_error);
 538
 539   dbus_message_unref(request_ptr);
 540
 541   if (reply_ptr == NULL)
 542   {
 543     log_error("no reply from JACK server, error is '%s'", g_dbus_error.message);
 544     dbus_error_free(&g_dbus_error);
 545     return false;
 546   }
 547
 548   reply_signature = dbus_message_get_signature(reply_ptr);
 549
 550   dbus_message_unref(reply_ptr);
 551
 552   if (strcmp(reply_signature, "") != 0)
 553   {
 554     log_error("ResetParameterValue() reply signature mismatch. '%s'", reply_signature);
 555     return false;
 556   }
 557
 558   return true;
 559 }
 560
 561 bool jack_proxy_start_server(void)
 562 {
 563   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "StartServer", "", "");
 564 }
 565
 566 bool jack_proxy_stop_server(void)
 567 {
 568   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "StopServer", "", "");
 569 }
 570
 571 bool jack_proxy_is_realtime(bool * realtime_ptr)
 572 {
 573   dbus_bool_t realtime;
 574
 575   if (!dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "IsStarted", "", "b", &realtime))
 576   {
 577     return false;
 578   }
 579
 580   *realtime_ptr = realtime;
 581   return true;
 582 }
 583
 584 bool jack_proxy_sample_rate(uint32_t * sample_rate_ptr)
 585 {
 586   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetSampleRate", "", "u", sample_rate_ptr);
 587 }
 588
 589 bool jack_proxy_get_xruns(uint32_t * xruns_ptr)
 590 {
 591   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetXruns", "", "u", xruns_ptr);
 592 }
 593
 594 bool jack_proxy_get_dsp_load(double * dsp_load_ptr)
 595 {
 596   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetLoad", "", "d", dsp_load_ptr);
 597 }
 598
 599 bool jack_proxy_get_buffer_size(uint32_t * size_ptr)
 600 {
 601   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetBufferSize", "", "u", size_ptr);
 602 }
 603
 604 bool jack_proxy_set_buffer_size(uint32_t size)
 605 {
 606   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "SetBufferSize", "u", &size, "");
 607 }
 608
 609 bool jack_proxy_reset_xruns(void)
 610 {
 611   return dbus_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "ResetXruns", "", "");
 612 }
 613
 614 static
 615 bool
 616 reset_callback(
 617   void * context,
 618   bool leaf,
 619   const char * address,
 620   char * child)
 621 {
 622   const char * component;
 623   char * dst;
 624   size_t len;
 625
 626   component = address;
 627   while (*component != 0)
 628   {
 629     component += strlen(component) + 1;
 630   }
 631
 632   /* address always is same buffer as the one in the jack_reset_all_params() stack */
 633   dst = (char *)component;
 634
 635   len = strlen(child) + 1;
 636   memcpy(dst, child, len);
 637   dst[len] = 0;
 638
 639   if (leaf)
 640   {
 641     if (!jack_proxy_reset_parameter_value(address))
 642     {
 643       log_error("cannot reset value of parameter");
 644       return false;
 645     }
 646   }
 647   else
 648   {
 649     if (!jack_proxy_read_conf_container(address, context, reset_callback))
 650     {
 651       log_error("cannot read container");
 652       return false;
 653     }
 654   }
 655
 656   *dst = 0;
 657
 658   return true;
 659 }
 660
 661 bool jack_reset_all_params(void)
 662 {
 663   char address[1024] = "";
 664
 665   return jack_proxy_read_conf_container(address, NULL, reset_callback);
 666 }