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