daemon/virtualizer.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the graph virtualizer object
   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 #include "virtualizer.h"
  28 #include "../dbus_constants.h"
  29 #include "a2j_proxy.h"
  30 #include "procfs.h"
  31 #include "app_supervisor.h"
  32 #include "studio_internal.h"
  33
  34 struct virtualizer
  35 {
  36
  37   graph_proxy_handle jack_graph_proxy;
  38   ladish_graph_handle jack_graph;
  39   ladish_graph_handle studio_graph;
  40   uint64_t system_client_id;
  41 };
  42
  43 /* 47c1cd18-7b21-4389-bec4-6e0658e1d6b1 */
  44 UUID_DEFINE(g_system_capture_uuid,0x47,0xC1,0xCD,0x18,0x7B,0x21,0x43,0x89,0xBE,0xC4,0x6E,0x06,0x58,0xE1,0xD6,0xB1);
  45
  46 /* b2a0bb06-28d8-4bfe-956e-eb24378f9629 */
  47 UUID_DEFINE(g_system_playback_uuid,0xB2,0xA0,0xBB,0x06,0x28,0xD8,0x4B,0xFE,0x95,0x6E,0xEB,0x24,0x37,0x8F,0x96,0x29);
  48
  49 /* be23a242-e2b2-11de-b795-002618af5e42 */
  50 UUID_DEFINE(g_a2j_uuid,0xBE,0x23,0xA2,0x42,0xE2,0xB2,0x11,0xDE,0xB7,0x95,0x00,0x26,0x18,0xAF,0x5E,0x42);
  51
  52 char * get_app_name(struct virtualizer * virtualizer_ptr, uint64_t client_id)
  53 {
  54   int64_t pid;
  55   unsigned long long ppid;
  56   char * app_name;
  57
  58   if (!graph_proxy_get_client_pid(virtualizer_ptr->jack_graph_proxy, client_id, &pid))
  59   {
  60     pid = 0;
  61   }
  62
  63   log_info("client pid is %"PRId64, pid);
  64   app_name = NULL;
  65   if (pid != 0)
  66   {
  67     ppid = (unsigned long long)pid;
  68   loop:
  69     app_name = ladish_app_supervisor_search_app(g_studio.app_supervisor, ppid);
  70     if (app_name == NULL)
  71     {
  72       ppid = procfs_get_process_parent(ppid);
  73       if (ppid != 0)
  74       {
  75         //log_info("parent pid %llu", ppid);
  76         goto loop;
  77       }
  78     }
  79   }
  80
  81   return app_name;
  82 }
  83
  84 #define virtualizer_ptr ((struct virtualizer *)context)
  85
  86 static void clear(void * context)
  87 {
  88   log_info("clear");
  89 }
  90
  91 static void client_appeared(void * context, uint64_t id, const char * name)
  92 {
  93   ladish_client_handle client;
  94   const char * a2j_name;
  95   bool is_a2j;
  96   char * app_name = NULL;
  97
  98   log_info("client_appeared(%"PRIu64", %s)", id, name);
  99
 100   a2j_name = a2j_proxy_get_jack_client_name_cached();
 101   is_a2j = a2j_name != NULL && strcmp(a2j_name, name) == 0;
 102
 103   if (is_a2j)
 104   {
 105     client = ladish_graph_find_client_by_uuid(virtualizer_ptr->jack_graph, g_a2j_uuid);
 106   }
 107   else
 108   {
 109     app_name = get_app_name(virtualizer_ptr, id);
 110     if (app_name != NULL)
 111     {
 112       log_info("app name is '%s'", app_name);
 113       name = app_name;
 114     }
 115
 116     client = ladish_graph_find_client_by_name(virtualizer_ptr->jack_graph, name);
 117   }
 118
 119   if (client != NULL)
 120   {
 121     log_info("found existing client");
 122     ASSERT(ladish_client_get_jack_id(client) == 0); /* two JACK clients with same name? */
 123     ladish_client_set_jack_id(client, id);
 124     ladish_graph_show_client(virtualizer_ptr->jack_graph, client);
 125     goto exit;
 126   }
 127
 128   if (!ladish_client_create(is_a2j ? g_a2j_uuid : NULL, true, false, false, &client))
 129   {
 130     log_error("ladish_client_create() failed. Ignoring client %"PRIu64" (%s)", id, name);
 131     return;
 132   }
 133
 134   ladish_client_set_jack_id(client, id);
 135
 136   if (!ladish_graph_add_client(virtualizer_ptr->jack_graph, client, name, false))
 137   {
 138     log_error("ladish_graph_add_client() failed to add client %"PRIu64" (%s) to JACK graph", id, name);
 139     ladish_client_destroy(client);
 140     return;
 141   }
 142
 143 exit:
 144   if (strcmp(name, "system") == 0)
 145   {
 146     virtualizer_ptr->system_client_id = id;
 147   }
 148
 149   if (app_name != NULL)
 150   {
 151     free(app_name);
 152   }
 153 }
 154
 155 static void client_disappeared(void * context, uint64_t id)
 156 {
 157   ladish_client_handle client;
 158
 159   log_info("client_disappeared(%"PRIu64")", id);
 160
 161   client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, id);
 162   if (client == NULL)
 163   {
 164     log_error("Unknown JACK client with id %"PRIu64" disappeared", id);
 165     return;
 166   }
 167
 168   if (id == virtualizer_ptr->system_client_id)
 169   {
 170     virtualizer_ptr->system_client_id = 0;
 171   }
 172
 173   if (true)                     /* if client is supposed to be persisted */
 174   {
 175     ladish_client_set_jack_id(client, 0);
 176     ladish_graph_hide_client(virtualizer_ptr->jack_graph, client);
 177   }
 178   else
 179   {
 180     ladish_graph_remove_client(virtualizer_ptr->jack_graph, client, false);
 181     ladish_client_destroy(client);
 182   }
 183 }
 184
 185 static void port_appeared(void * context, uint64_t client_id, uint64_t port_id, const char * port_name, bool is_input, bool is_terminal, bool is_midi)
 186 {
 187   ladish_client_handle jack_client;
 188   ladish_client_handle studio_client;
 189   ladish_port_handle port;
 190   uint32_t type;
 191   uint32_t flags;
 192   const char * jack_client_name;
 193   bool is_a2j;
 194   uuid_t client_uuid;
 195   char * alsa_client_name;
 196   char * alsa_port_name;
 197   uint32_t alsa_client_id;
 198
 199   log_info("port_appeared(%"PRIu64", %"PRIu64", %s (%s, %s))", client_id, port_id, port_name, is_input ? "in" : "out", is_midi ? "midi" : "audio");
 200
 201   jack_client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, client_id);
 202   if (jack_client == NULL)
 203   {
 204     log_error("Port of unknown JACK client with id %"PRIu64" appeared", client_id);
 205     goto fail;
 206   }
 207
 208   ladish_client_get_uuid(jack_client, client_uuid);
 209   is_a2j = uuid_compare(client_uuid, g_a2j_uuid) == 0;
 210   if (is_a2j)
 211   {
 212     log_info("a2j port appeared");
 213     if (!a2j_proxy_map_jack_port(port_name, &alsa_client_name, &alsa_port_name, &alsa_client_id))
 214     {
 215       is_a2j = false;
 216     }
 217     else
 218     {
 219       log_info("a2j: '%s':'%s' (%"PRIu32")", alsa_client_name, alsa_port_name, alsa_client_id);
 220     }
 221   }
 222
 223   jack_client_name = ladish_graph_get_client_name(virtualizer_ptr->jack_graph, jack_client);
 224
 225   type = is_midi ? JACKDBUS_PORT_TYPE_MIDI : JACKDBUS_PORT_TYPE_AUDIO;
 226   flags = is_input ? JACKDBUS_PORT_FLAG_INPUT : JACKDBUS_PORT_FLAG_OUTPUT;
 227   if (is_terminal)
 228   {
 229     flags |= JACKDBUS_PORT_FLAG_TERMINAL;
 230   }
 231
 232   port = ladish_graph_find_port_by_name(virtualizer_ptr->jack_graph, jack_client, port_name);
 233   if (port != NULL)
 234   {
 235     log_info("found existing port");
 236
 237     ASSERT(ladish_port_get_jack_id(port) == 0); /* two JACK ports with same name? */
 238     ladish_port_set_jack_id(port, port_id);
 239     ladish_graph_adjust_port(virtualizer_ptr->jack_graph, port, type, flags);
 240     ladish_graph_show_port(virtualizer_ptr->jack_graph, port);
 241
 242     studio_client = ladish_graph_get_port_client(virtualizer_ptr->studio_graph, port);
 243     if (studio_client == NULL)
 244     {
 245       log_error("JACK port not found in studio graph");
 246       ASSERT_NO_PASS;
 247       goto free_alsa_names;
 248     }
 249
 250     ladish_client_set_jack_id(studio_client, client_id);
 251     ladish_graph_adjust_port(virtualizer_ptr->studio_graph, port, type, flags);
 252     ladish_graph_show_port(virtualizer_ptr->studio_graph, port);
 253     goto free_alsa_names;
 254   }
 255
 256   if (!ladish_port_create(NULL, &port))
 257   {
 258     log_error("ladish_port_create() failed.");
 259     goto free_alsa_names;
 260   }
 261
 262   ladish_port_set_jack_id(port, port_id);
 263
 264   if (!ladish_graph_add_port(virtualizer_ptr->jack_graph, jack_client, port, port_name, type, flags, false))
 265   {
 266     log_error("ladish_graph_add_port() failed.");
 267     ladish_port_destroy(port);
 268     goto free_alsa_names;
 269   }
 270
 271   if (is_a2j)
 272   {
 273     studio_client = ladish_graph_find_client_by_name(virtualizer_ptr->studio_graph, alsa_client_name);
 274     if (studio_client == NULL)
 275     {
 276         if (!ladish_client_create(g_a2j_uuid, true, false, true, &studio_client))
 277         {
 278           log_error("ladish_client_create() failed.");
 279           goto free_alsa_names;
 280         }
 281
 282         if (!ladish_graph_add_client(virtualizer_ptr->studio_graph, studio_client, alsa_client_name, false))
 283         {
 284           log_error("ladish_graph_add_client() failed.");
 285           ladish_client_destroy(studio_client);
 286           goto free_alsa_names;
 287         }
 288     }
 289
 290     port_name = alsa_port_name;
 291   }
 292   else if (client_id == virtualizer_ptr->system_client_id)
 293   {
 294     log_info("system client port appeared");
 295
 296     if (!is_input)
 297     { /* output capture port */
 298
 299       studio_client = ladish_graph_find_client_by_uuid(virtualizer_ptr->studio_graph, g_system_capture_uuid);
 300       if (studio_client == NULL)
 301       {
 302         if (!ladish_client_create(g_system_capture_uuid, true, false, true, &studio_client))
 303         {
 304           log_error("ladish_client_create() failed.");
 305           goto free_alsa_names;
 306         }
 307
 308         if (!ladish_graph_add_client(virtualizer_ptr->studio_graph, studio_client, "Hardware Capture", false))
 309         {
 310           log_error("ladish_graph_add_client() failed.");
 311           ladish_client_destroy(studio_client);
 312           goto free_alsa_names;
 313         }
 314       }
 315     }
 316     else
 317     { /* input playback port */
 318       studio_client = ladish_graph_find_client_by_uuid(virtualizer_ptr->studio_graph, g_system_playback_uuid);
 319       if (studio_client == NULL)
 320       {
 321         if (!ladish_client_create(g_system_playback_uuid, true, false, true, &studio_client))
 322         {
 323           log_error("ladish_client_create() failed.");
 324           goto free_alsa_names;
 325         }
 326
 327         if (!ladish_graph_add_client(virtualizer_ptr->studio_graph, studio_client, "Hardware Playback", false))
 328         {
 329           ladish_client_destroy(studio_client);
 330           goto free_alsa_names;
 331         }
 332       }
 333     }
 334   }
 335   else
 336   { /* non-system client */
 337     log_info("non-system client port appeared");
 338
 339     studio_client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->studio_graph, client_id);
 340     if (studio_client == NULL)
 341     {
 342       if (!ladish_client_create(NULL, false, false, false, &studio_client))
 343       {
 344         log_error("ladish_client_create() failed.");
 345         goto free_alsa_names;
 346       }
 347
 348       ladish_client_set_jack_id(studio_client, client_id);
 349
 350       if (!ladish_graph_add_client(virtualizer_ptr->studio_graph, studio_client, jack_client_name, false))
 351       {
 352         log_error("ladish_graph_add_client() failed to add client '%s' to studio graph", jack_client_name);
 353         ladish_client_destroy(studio_client);
 354         goto free_alsa_names;
 355       }
 356     }
 357   }
 358
 359   if (!ladish_graph_add_port(virtualizer_ptr->studio_graph, studio_client, port, port_name, type, flags, false))
 360   {
 361     log_error("ladish_graph_add_port() failed.");
 362     goto free_alsa_names;
 363   }
 364
 365 free_alsa_names:
 366   if (is_a2j)
 367   {
 368     free(alsa_client_name);
 369     free(alsa_port_name);
 370   }
 371
 372 fail:
 373   return;
 374 }
 375
 376 static void port_disappeared(void * context, uint64_t client_id, uint64_t port_id)
 377 {
 378   ladish_client_handle client;
 379   ladish_port_handle port;
 380
 381   log_info("port_disappeared(%"PRIu64")", port_id);
 382
 383   client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, client_id);
 384   if (client == NULL)
 385   {
 386     log_error("Port of unknown JACK client with id %"PRIu64" disappeared", client_id);
 387     return;
 388   }
 389
 390   port = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port_id);
 391   if (port == NULL)
 392   {
 393     log_error("Unknown JACK port with id %"PRIu64" disappeared", port_id);
 394     return;
 395   }
 396
 397   if (true)                     /* if client is supposed to be persisted */
 398   {
 399     ladish_port_set_jack_id(port, 0);
 400     ladish_graph_hide_port(virtualizer_ptr->jack_graph, port);
 401     ladish_graph_hide_port(virtualizer_ptr->studio_graph, port);
 402     client = ladish_graph_get_port_client(virtualizer_ptr->studio_graph, port);
 403     if (ladish_graph_is_client_looks_empty(virtualizer_ptr->studio_graph, client))
 404     {
 405         ladish_graph_hide_client(virtualizer_ptr->studio_graph, client);
 406     }
 407   }
 408   else
 409   {
 410     ladish_graph_remove_port(virtualizer_ptr->jack_graph, port);
 411
 412     client = ladish_graph_remove_port(virtualizer_ptr->studio_graph, port);
 413     if (client != NULL)
 414     {
 415       if (ladish_graph_is_client_empty(virtualizer_ptr->studio_graph, client))
 416       {
 417         ladish_graph_remove_client(virtualizer_ptr->studio_graph, client, false);
 418       }
 419     }
 420   }
 421 }
 422
 423 static bool ports_connect_request(void * context, ladish_graph_handle graph_handle, ladish_port_handle port1, ladish_port_handle port2)
 424 {
 425   uint64_t port1_id;
 426   uint64_t port2_id;
 427
 428   ASSERT(graph_handle == virtualizer_ptr->studio_graph);
 429   log_info("virtualizer: ports connect request");
 430
 431   port1_id = ladish_port_get_jack_id(port1);
 432   port2_id = ladish_port_get_jack_id(port2);
 433
 434   graph_proxy_connect_ports(virtualizer_ptr->jack_graph_proxy, port1_id, port2_id);
 435
 436   return true;
 437 }
 438
 439 static bool ports_disconnect_request(void * context, ladish_graph_handle graph_handle, uint64_t connection_id)
 440 {
 441   ladish_port_handle port1;
 442   ladish_port_handle port2;
 443   uint64_t port1_id;
 444   uint64_t port2_id;
 445
 446   log_info("virtualizer: ports disconnect request");
 447
 448   ASSERT(graph_handle == virtualizer_ptr->studio_graph);
 449
 450   if (!ladish_graph_get_connection_ports(virtualizer_ptr->studio_graph, connection_id, &port1, &port2))
 451   {
 452     log_error("cannot find ports that are disconnect-requested");
 453     ASSERT_NO_PASS;
 454     return false;
 455   }
 456
 457   port1_id = ladish_port_get_jack_id(port1);
 458   port2_id = ladish_port_get_jack_id(port2);
 459
 460   graph_proxy_disconnect_ports(virtualizer_ptr->jack_graph_proxy, port1_id, port2_id);
 461
 462   return true;
 463 }
 464
 465 static void ports_connected(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id)
 466 {
 467   ladish_port_handle port1;
 468   ladish_port_handle port2;
 469   uint64_t connection_id;
 470
 471   log_info("ports_connected %"PRIu64":%"PRIu64" %"PRIu64":%"PRIu64"", client1_id, port1_id, client2_id, port2_id);
 472
 473   port1 = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port1_id);
 474   if (port1 == NULL)
 475   {
 476     log_error("Unknown JACK port with id %"PRIu64" connected", port1_id);
 477     return;
 478   }
 479
 480   port2 = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port2_id);
 481   if (port2 == NULL)
 482   {
 483     log_error("Unknown JACK port with id %"PRIu64" connected", port2_id);
 484     return;
 485   }
 486
 487   ladish_graph_add_connection(virtualizer_ptr->jack_graph, port1, port2, false);
 488
 489   if (ladish_graph_find_connection(virtualizer_ptr->studio_graph, port1, port2, &connection_id))
 490   {
 491     log_info("showing hidden connection");
 492     ladish_graph_show_connection(virtualizer_ptr->studio_graph, connection_id);
 493   }
 494   else
 495   {
 496     log_info("creating new connection");
 497     ladish_graph_add_connection(virtualizer_ptr->studio_graph, port1, port2, false);
 498   }
 499 }
 500
 501 static void ports_disconnected(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id)
 502 {
 503   ladish_port_handle port1;
 504   ladish_port_handle port2;
 505   uint64_t connection_id;
 506
 507   log_info("ports_disconnected %"PRIu64":%"PRIu64" %"PRIu64":%"PRIu64"", client1_id, port1_id, client2_id, port2_id);
 508
 509   port1 = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port1_id);
 510   if (port1 == NULL)
 511   {
 512     log_error("Unknown JACK port with id %"PRIu64" disconnected", port1_id);
 513     return;
 514   }
 515
 516   port2 = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port2_id);
 517   if (port2 == NULL)
 518   {
 519     log_error("Unknown JACK port with id %"PRIu64" disconnected", port2_id);
 520     return;
 521   }
 522
 523   if (ladish_graph_find_connection(virtualizer_ptr->jack_graph, port1, port2, &connection_id))
 524   {
 525     ladish_graph_remove_connection(virtualizer_ptr->jack_graph, connection_id);
 526   }
 527   else
 528   {
 529     log_error("ports %"PRIu64":%"PRIu64" and %"PRIu64":%"PRIu64" are not connected in the JACK graph", client1_id, port1_id, client2_id, port2_id);
 530   }
 531
 532   if (ladish_graph_find_connection(virtualizer_ptr->studio_graph, port1, port2, &connection_id))
 533   {
 534     ladish_graph_remove_connection(virtualizer_ptr->studio_graph, connection_id);
 535   }
 536   else
 537   {
 538     log_error("ports %"PRIu64":%"PRIu64" and %"PRIu64":%"PRIu64" are not connected in the Studio graph", client1_id, port1_id, client2_id, port2_id);
 539   }
 540 }
 541
 542 #undef virtualizer_ptr
 543
 544 bool
 545 ladish_virtualizer_create(
 546   graph_proxy_handle jack_graph_proxy,
 547   ladish_graph_handle jack_graph,
 548   ladish_graph_handle studio_graph,
 549   ladish_virtualizer_handle * handle_ptr)
 550 {
 551   struct virtualizer * virtualizer_ptr;
 552
 553   virtualizer_ptr = malloc(sizeof(struct virtualizer));
 554   if (virtualizer_ptr == NULL)
 555   {
 556     log_error("malloc() failed for struct virtualizer");
 557     return false;
 558   }
 559
 560   virtualizer_ptr->jack_graph_proxy = jack_graph_proxy;
 561   virtualizer_ptr->jack_graph = jack_graph;
 562   virtualizer_ptr->studio_graph = studio_graph;
 563   virtualizer_ptr->system_client_id = 0;
 564
 565   if (!graph_proxy_attach(
 566         jack_graph_proxy,
 567         virtualizer_ptr,
 568         clear,
 569         client_appeared,
 570         client_disappeared,
 571         port_appeared,
 572         port_disappeared,
 573         ports_connected,
 574         ports_disconnected))
 575   {
 576     free(virtualizer_ptr);
 577     return false;
 578   }
 579
 580   ladish_graph_set_connection_handlers(studio_graph, virtualizer_ptr, ports_connect_request, ports_disconnect_request);
 581
 582   *handle_ptr = (ladish_virtualizer_handle)virtualizer_ptr;
 583   return true;
 584 }
 585
 586 #define virtualizer_ptr ((struct virtualizer *)handle)
 587
 588 void
 589 ladish_virtualizer_destroy(
 590   ladish_virtualizer_handle handle)
 591 {
 592   log_info("ladish_virtualizer_destroy() called");
 593
 594   graph_proxy_detach((graph_proxy_handle)handle, virtualizer_ptr);
 595 }
 596
 597 #undef virtualizer_ptr