daemon/virtualizer.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 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 "../proxies/a2j_proxy.h"
  30 #include "../proxies/jmcore_proxy.h"
  31 #include "procfs.h"
  32 #include "app_supervisor.h"
  33 #include "studio_internal.h"
  34 #include "../common/catdup.h"
  35 #include "room.h"
  36 #include "studio.h"
  37
  38 struct virtualizer
  39 {
  40   graph_proxy_handle jack_graph_proxy;
  41   ladish_graph_handle jack_graph;
  42   uint64_t system_client_id;
  43   unsigned int our_clients_count;
  44 };
  45
  46 /* 47c1cd18-7b21-4389-bec4-6e0658e1d6b1 */
  47 UUID_DEFINE(g_system_capture_uuid,0x47,0xC1,0xCD,0x18,0x7B,0x21,0x43,0x89,0xBE,0xC4,0x6E,0x06,0x58,0xE1,0xD6,0xB1);
  48
  49 /* b2a0bb06-28d8-4bfe-956e-eb24378f9629 */
  50 UUID_DEFINE(g_system_playback_uuid,0xB2,0xA0,0xBB,0x06,0x28,0xD8,0x4B,0xFE,0x95,0x6E,0xEB,0x24,0x37,0x8F,0x96,0x29);
  51
  52 /* be23a242-e2b2-11de-b795-002618af5e42 */
  53 UUID_DEFINE(g_a2j_uuid,0xBE,0x23,0xA2,0x42,0xE2,0xB2,0x11,0xDE,0xB7,0x95,0x00,0x26,0x18,0xAF,0x5E,0x42);
  54
  55 struct app_find_context
  56 {
  57   pid_t pid;
  58   ladish_graph_handle graph;
  59   ladish_app_handle app;
  60 };
  61
  62 #define app_find_context_ptr ((struct app_find_context *)context)
  63
  64 static bool lookup_app_in_supervisor(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
  65 {
  66   pid_t pid;
  67   ladish_app_handle app;
  68
  69   /* we stop iteration when app is found */
  70   ASSERT(app_find_context_ptr->app == NULL && app_find_context_ptr->graph == NULL);
  71
  72   //log_info("checking app supervisor \"%s\" for pid %llu", ladish_app_supervisor_get_name(app_supervisor), (unsigned long long)pid);
  73
  74   pid = app_find_context_ptr->pid;
  75   do
  76   {
  77     app = ladish_app_supervisor_find_app_by_pid(app_supervisor, pid);
  78     if (app != NULL)
  79       break;
  80
  81     pid = (pid_t)procfs_get_process_parent((unsigned long long)pid);
  82 #if 0
  83     if (pid != 0)
  84     {
  85       log_info("parent pid %llu", (unsigned long long)pid);
  86     }
  87 #endif
  88   }
  89   while (pid != 0);
  90
  91   if (app == NULL)
  92   {                            /* app not found in current supervisor */
  93     return true;               /* continue app supervisor iteration */
  94   }
  95
  96   app_find_context_ptr->app = app;
  97   app_find_context_ptr->graph = graph;
  98
  99   return false;               /* stop app supervisor iteration */
 100 }
 101
 102 #undef app_find_context_ptr
 103
 104 static ladish_app_handle ladish_virtualizer_find_app_by_pid(struct virtualizer * virtualizer_ptr, pid_t pid, ladish_graph_handle * graph_ptr)
 105 {
 106   struct app_find_context context;
 107
 108   context.pid = pid;
 109   context.app = NULL;
 110   context.graph = NULL;
 111
 112   ladish_studio_iterate_virtual_graphs(&context, lookup_app_in_supervisor);
 113
 114   if (context.app == NULL)
 115   { /* app not found */
 116     ASSERT(context.graph == NULL);
 117     return NULL;
 118   }
 119
 120   ASSERT(context.graph != NULL);
 121   *graph_ptr = context.graph;
 122
 123   return context.app;
 124 }
 125
 126 struct find_link_port_context
 127 {
 128   uuid_t uuid;
 129   uint64_t jack_id;
 130   ladish_port_handle port;
 131   ladish_graph_handle graph;
 132 };
 133
 134 #define find_link_port_context_ptr ((struct find_link_port_context *)context)
 135
 136 static bool find_link_port_vgraph_callback_by_uuid(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
 137 {
 138   ladish_port_handle port;
 139
 140   port = ladish_graph_find_port_by_uuid(graph, find_link_port_context_ptr->uuid, true);
 141   if (port != NULL)
 142   {
 143     find_link_port_context_ptr->port = port;
 144     find_link_port_context_ptr->graph = graph;
 145     return false;
 146   }
 147
 148   return true;                  /* continue vgraph iteration */
 149 }
 150
 151 static bool find_link_port_vgraph_callback_by_jack_id(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
 152 {
 153   ladish_port_handle port;
 154   bool room;
 155
 156   log_info("searching link port with jack id %"PRIu64" in graph %s", find_link_port_context_ptr->jack_id, ladish_graph_get_description(graph));
 157
 158   room = graph != g_studio.studio_graph;
 159
 160   port = ladish_graph_find_port_by_jack_id(graph, find_link_port_context_ptr->jack_id, room, !room);
 161   if (port != NULL)
 162   {
 163     find_link_port_context_ptr->port = port;
 164     find_link_port_context_ptr->graph = graph;
 165     return false;
 166   }
 167
 168   return true;                  /* continue vgraph iteration */
 169 }
 170
 171 #undef find_link_port_context_ptr
 172
 173 static ladish_graph_handle find_link_port_vgraph_by_uuid(struct virtualizer * virtualizer_ptr, const char * port_name, ladish_port_handle * port_ptr)
 174 {
 175   struct find_link_port_context context;
 176
 177   uuid_parse(port_name, context.uuid);
 178   context.graph = NULL;
 179   context.port = NULL;
 180
 181   ladish_studio_iterate_virtual_graphs(&context, find_link_port_vgraph_callback_by_uuid);
 182
 183   if (port_ptr != NULL && context.graph != NULL)
 184   {
 185     *port_ptr = context.port;
 186   }
 187
 188   return context.graph;
 189 }
 190
 191 static ladish_graph_handle find_link_port_vgraph_by_jack_id(struct virtualizer * virtualizer_ptr, uint64_t jack_id, ladish_port_handle * port_ptr)
 192 {
 193   struct find_link_port_context context;
 194
 195   context.jack_id = jack_id;
 196   context.graph = NULL;
 197   context.port = NULL;
 198
 199   ladish_studio_iterate_virtual_graphs(&context, find_link_port_vgraph_callback_by_jack_id);
 200
 201   if (port_ptr != NULL && context.graph != NULL)
 202   {
 203     *port_ptr = context.port;
 204   }
 205
 206   return context.graph;
 207 }
 208
 209 static
 210 bool
 211 lookup_port(
 212   struct virtualizer * virtualizer_ptr,
 213   uint64_t port_id,
 214   ladish_port_handle * port_ptr,
 215   ladish_graph_handle * vgraph_ptr)
 216 {
 217   ladish_port_handle port;
 218   ladish_client_handle jclient;
 219   ladish_graph_handle vgraph;
 220
 221   port = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
 222   if (port == NULL)
 223   {
 224     log_error("Unknown JACK port with id %"PRIu64" (dis)connected", port_id);
 225     return false;
 226   }
 227
 228   jclient = ladish_graph_get_port_client(virtualizer_ptr->jack_graph, port);
 229   if (jclient == NULL)
 230   {
 231     log_error("Port %"PRIu64" without jack client was (dis)connected", port_id);
 232     return false;
 233   }
 234
 235   vgraph = ladish_client_get_vgraph(jclient);
 236   if (vgraph == NULL)
 237   {
 238     vgraph = find_link_port_vgraph_by_jack_id(virtualizer_ptr, port_id, NULL);
 239     if (vgraph == NULL)
 240     {
 241       log_error("Cannot find vgraph for (dis)connected jmcore port");
 242       return false;
 243     }
 244
 245     log_info("link port found in graph %s", ladish_graph_get_description(vgraph));
 246   }
 247
 248   *port_ptr = port;
 249   *vgraph_ptr = vgraph;
 250   return true;
 251 }
 252
 253 #define virtualizer_ptr ((struct virtualizer *)context)
 254
 255 static void clear(void * context)
 256 {
 257   log_info("clear");
 258 }
 259
 260 static void client_appeared(void * context, uint64_t id, const char * jack_name)
 261 {
 262   ladish_client_handle client;
 263   const char * a2j_name;
 264   bool is_a2j;
 265   ladish_app_handle app;
 266   uuid_t app_uuid;
 267   const char * name;
 268   pid_t pid;
 269   ladish_graph_handle graph;
 270   bool jmcore;
 271
 272   log_info("client_appeared(%"PRIu64", %s)", id, jack_name);
 273
 274   a2j_name = a2j_proxy_get_jack_client_name_cached();
 275   is_a2j = a2j_name != NULL && strcmp(a2j_name, jack_name) == 0;
 276
 277   name = jack_name;
 278   app = NULL;
 279   graph = NULL;
 280   jmcore = false;
 281
 282   if (!graph_proxy_get_client_pid(virtualizer_ptr->jack_graph_proxy, id, &pid))
 283   {
 284     log_info("client %"PRIu64" pid is unknown", id);
 285   }
 286   else
 287   {
 288     log_info("client pid is %"PRId64, (int64_t)pid);
 289
 290     if (pid != 0) /* skip internal clients that will match the pending clients in the graph, both have zero pid */
 291     {
 292       jmcore = pid == jmcore_proxy_get_pid_cached();
 293       if (jmcore)
 294       {
 295         log_info("jmcore client appeared");
 296       }
 297       else
 298       {
 299         app = ladish_virtualizer_find_app_by_pid(virtualizer_ptr, pid, &graph);
 300         if (app != NULL)
 301         {
 302           ladish_app_get_uuid(app, app_uuid);
 303           ASSERT(!uuid_is_null(app_uuid));
 304           name = ladish_app_get_name(app);
 305           log_info("app name is '%s'", name);
 306         }
 307       }
 308     }
 309   }
 310
 311   if (!jmcore)
 312   {
 313     if (is_a2j)
 314     {
 315       client = ladish_graph_find_client_by_uuid(virtualizer_ptr->jack_graph, g_a2j_uuid);
 316     }
 317     else
 318     {
 319       client = ladish_graph_find_client_by_app(virtualizer_ptr->jack_graph, app_uuid);
 320       if (client == NULL)
 321       {
 322         log_info("Lookup by app uuid failed, attempting lookup by name '%s'", name);
 323         client = ladish_graph_find_client_by_name(virtualizer_ptr->jack_graph, name, true);
 324       }
 325     }
 326
 327     if (client != NULL)
 328     {
 329       log_info("found existing client");
 330       if (ladish_client_get_jack_id(client) != 0)
 331       {
 332         log_error("Ignoring client with duplicate name '%s' ('%s')", name, jack_name);
 333         goto exit;
 334       }
 335
 336       ladish_client_set_jack_id(client, id);
 337       ladish_graph_show_client(virtualizer_ptr->jack_graph, client);
 338       goto done;
 339     }
 340   }
 341
 342   if (!ladish_client_create(is_a2j ? g_a2j_uuid : NULL, &client))
 343   {
 344     log_error("ladish_client_create() failed. Ignoring client %"PRIu64" (%s)", id, jack_name);
 345     goto exit;
 346   }
 347
 348   ladish_client_set_jack_id(client, id);
 349
 350   if (!ladish_graph_add_client(virtualizer_ptr->jack_graph, client, name, false))
 351   {
 352     log_error("ladish_graph_add_client() failed to add client %"PRIu64" (%s) to JACK graph", id, name);
 353     ladish_client_destroy(client);
 354     goto exit;
 355   }
 356
 357 done:
 358   if (strcmp(jack_name, "system") == 0)
 359   {
 360     virtualizer_ptr->system_client_id = id;
 361   }
 362
 363   if (app != NULL)
 364   {
 365     /* interlink client and app */
 366     ladish_app_add_pid(app, pid);
 367     ladish_client_set_pid(client, pid);
 368     ladish_client_set_app(client, app_uuid);
 369
 370     ASSERT(graph);
 371     ladish_client_set_vgraph(client, graph);
 372     virtualizer_ptr->our_clients_count++;
 373   }
 374   else if (jmcore)
 375   {
 376     ladish_client_set_pid(client, pid);
 377     ASSERT(ladish_client_get_vgraph(client) == NULL);
 378   }
 379   else
 380   {
 381     /* unknown and internal clients appear in the studio graph */
 382     ladish_client_set_vgraph(client, g_studio.studio_graph);
 383   }
 384
 385 exit:
 386   return;
 387 }
 388
 389 static void client_disappeared(void * context, uint64_t id)
 390 {
 391   ladish_client_handle client;
 392   pid_t pid;
 393   ladish_graph_handle vgraph;
 394
 395   log_info("client_disappeared(%"PRIu64")", id);
 396
 397   client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, id);
 398   if (client == NULL)
 399   {
 400     log_error("Unknown JACK client with id %"PRIu64" disappeared", id);
 401     return;
 402   }
 403
 404   log_info("client disappeared: '%s'", ladish_graph_get_client_name(virtualizer_ptr->jack_graph, client));
 405
 406   vgraph = ladish_client_get_vgraph(client);
 407
 408   pid = ladish_client_get_pid(client);
 409   if (pid != 0 && pid != jmcore_proxy_get_pid_cached())
 410   {
 411     virtualizer_ptr->our_clients_count--;
 412   }
 413
 414   if (id == virtualizer_ptr->system_client_id)
 415   {
 416     virtualizer_ptr->system_client_id = 0;
 417   }
 418
 419   if (vgraph != NULL && ladish_graph_is_persist(vgraph)) /* if client is supposed to be persisted */
 420   {
 421     ladish_client_set_jack_id(client, 0);
 422     ladish_graph_hide_client(virtualizer_ptr->jack_graph, client);
 423   }
 424   else
 425   {
 426     ladish_graph_remove_client(virtualizer_ptr->jack_graph, client);
 427     ladish_client_destroy(client);
 428     /* no need to clear vclient interlink because it either does not exist (vgraph is NULL) or
 429      * it will be destroyed before it is accessed (persist flag is cleared on room deletion) */
 430   }
 431 }
 432
 433 static
 434 void
 435 port_appeared(
 436   void * context,
 437   uint64_t client_id,
 438   uint64_t port_id,
 439   const char * real_jack_port_name,
 440   bool is_input,
 441   bool is_terminal,
 442   bool is_midi)
 443 {
 444   ladish_client_handle jack_client;
 445   ladish_client_handle vclient;
 446   ladish_port_handle port;
 447   uint32_t type;
 448   uint32_t flags;
 449   const char * jack_client_name;
 450   bool is_a2j;
 451   uuid_t jclient_uuid;
 452   uuid_t vclient_uuid;
 453   bool has_app;
 454   uuid_t app_uuid;
 455   char * alsa_client_name;
 456   char * alsa_port_name;
 457   char * a2j_fake_jack_port_name = NULL;
 458   uint32_t alsa_client_id;
 459   const char * jack_port_name;
 460   const char * vport_name;
 461   ladish_graph_handle vgraph;
 462
 463   log_info("port_appeared(%"PRIu64", %"PRIu64", %s (%s, %s))", client_id, port_id, real_jack_port_name, is_input ? "in" : "out", is_midi ? "midi" : "audio");
 464
 465   type = is_midi ? JACKDBUS_PORT_TYPE_MIDI : JACKDBUS_PORT_TYPE_AUDIO;
 466   flags = is_input ? JACKDBUS_PORT_FLAG_INPUT : JACKDBUS_PORT_FLAG_OUTPUT;
 467   if (is_terminal)
 468   {
 469     flags |= JACKDBUS_PORT_FLAG_TERMINAL;
 470   }
 471
 472   /********************/
 473   /* gather info about the appeared port */
 474
 475   jack_client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, client_id);
 476   if (jack_client == NULL)
 477   {
 478     log_error("Port of unknown JACK client with id %"PRIu64" appeared", client_id);
 479     goto exit;
 480   }
 481
 482   has_app = ladish_client_get_app(jack_client, app_uuid);
 483
 484   /* find the virtual graph that owns the app that owns the client that owns the appeared port */
 485   vgraph = ladish_client_get_vgraph(jack_client);
 486   if (vgraph == NULL)
 487   {
 488     vgraph = find_link_port_vgraph_by_uuid(virtualizer_ptr, real_jack_port_name, &port);
 489     if (vgraph == NULL)
 490     {
 491       log_error("Cannot find vgraph for appeared jmcore port '%s'", real_jack_port_name);
 492       goto exit;
 493     }
 494
 495     /* jmcore port appeared */
 496
 497     log_info("jmcore port appeared in vgraph %s", ladish_graph_get_description(vgraph));
 498
 499     if (!ladish_graph_add_port(virtualizer_ptr->jack_graph, jack_client, port, real_jack_port_name, type, flags, false))
 500     {
 501       log_error("ladish_graph_add_port() failed.");
 502       goto exit;
 503     }
 504
 505     if (vgraph == g_studio.studio_graph)
 506     {
 507       ladish_port_set_jack_id(port, port_id);
 508     }
 509     else
 510     {
 511       ladish_port_set_jack_id_room(port, port_id);
 512     }
 513
 514     vclient = ladish_graph_get_port_client(vgraph, port);
 515     if (vclient == NULL)
 516     {
 517       log_error("link port client not found in vgraph %s", ladish_graph_get_description(vgraph));
 518       ASSERT_NO_PASS;
 519       goto exit;
 520     }
 521
 522     ladish_graph_show_port(vgraph, port);
 523     goto exit;
 524   }
 525
 526   jack_client_name = ladish_graph_get_client_name(virtualizer_ptr->jack_graph, jack_client);
 527
 528   ladish_client_get_uuid(jack_client, jclient_uuid);
 529   is_a2j = uuid_compare(jclient_uuid, g_a2j_uuid) == 0;
 530   if (is_a2j)
 531   {
 532     log_info("a2j port appeared");
 533     if (!a2j_proxy_map_jack_port(real_jack_port_name, &alsa_client_name, &alsa_port_name, &alsa_client_id))
 534     {
 535       is_a2j = false;
 536       alsa_client_name = catdup("FAILED ", jack_client_name);
 537       if (alsa_client_name == NULL)
 538       {
 539         log_error("catdup failed to duplicate a2j jack client name after map failure");
 540         goto exit;
 541       }
 542
 543       alsa_port_name = strdup(real_jack_port_name);
 544       if (alsa_port_name == NULL)
 545       {
 546         log_error("catdup failed to duplicate a2j jack port name after map failure");
 547         free(alsa_client_name);
 548         goto exit;
 549       }
 550     }
 551     else
 552     {
 553       log_info("a2j: '%s':'%s' (%"PRIu32")", alsa_client_name, alsa_port_name, alsa_client_id);
 554     }
 555
 556     a2j_fake_jack_port_name = catdup4(alsa_client_name, is_input ? " (playback)" : " (capture)", ": ", alsa_port_name);
 557     if (a2j_fake_jack_port_name == NULL)
 558     {
 559       log_error("catdup4() failed");
 560       goto free_alsa_names;
 561     }
 562
 563     jack_port_name = a2j_fake_jack_port_name;
 564   }
 565   else
 566   {
 567     jack_port_name = real_jack_port_name;
 568   }
 569
 570   /********************/
 571
 572   /* search (by name) the appeared port in jack graph
 573    * if found - show it in both graphs.
 574    * if not found - create new port and add it to the jack graph.
 575    * Then process to adding it to virtual graph */
 576
 577   port = ladish_graph_find_port_by_name(virtualizer_ptr->jack_graph, jack_client, jack_port_name);
 578   if (port != NULL)
 579   {
 580     log_info("found existing port");
 581
 582     if (ladish_port_get_jack_id(port) != 0)
 583     {
 584       log_error("Ignoring duplicate JACK port '%s':'%s'", jack_client_name, jack_port_name);
 585       goto free_alsa_names;
 586     }
 587
 588     ladish_port_set_jack_id(port, port_id);
 589     ladish_graph_adjust_port(virtualizer_ptr->jack_graph, port, type, flags);
 590     ladish_graph_show_port(virtualizer_ptr->jack_graph, port);
 591
 592     vclient = ladish_graph_get_port_client(vgraph, port);
 593     if (vclient == NULL)
 594     {
 595       log_error("JACK port not found in virtual graph");
 596       ASSERT_NO_PASS;
 597       goto free_alsa_names;
 598     }
 599
 600     ladish_client_set_jack_id(vclient, client_id);
 601     ladish_graph_adjust_port(vgraph, port, type, flags);
 602     ladish_graph_show_port(vgraph, port);
 603     goto free_alsa_names;
 604   }
 605
 606   if (!ladish_port_create(NULL, false, &port))
 607   {
 608     log_error("ladish_port_create() failed.");
 609     goto free_alsa_names;
 610   }
 611
 612   /* set port jack id so invisible connections to/from it can be restored */
 613   ladish_port_set_jack_id(port, port_id);
 614
 615   if (!ladish_graph_add_port(virtualizer_ptr->jack_graph, jack_client, port, jack_port_name, type, flags, false))
 616   {
 617     log_error("ladish_graph_add_port() failed.");
 618     ladish_port_destroy(port);
 619     goto free_alsa_names;
 620   }
 621
 622   /********************/
 623   /* find/create the virtual client where port will be added */
 624
 625   if (is_a2j)
 626   {
 627     vclient = ladish_graph_find_client_by_name(vgraph, alsa_client_name, false);
 628     if (vclient == NULL)
 629     {
 630         if (!ladish_client_create(NULL, &vclient))
 631         {
 632           log_error("ladish_client_create() failed.");
 633           goto free_alsa_names;
 634         }
 635
 636         if (!ladish_graph_add_client(vgraph, vclient, alsa_client_name, false))
 637         {
 638           log_error("ladish_graph_add_client() failed.");
 639           ladish_client_destroy(vclient);
 640           goto free_alsa_names;
 641         }
 642     }
 643   }
 644   else if (client_id == virtualizer_ptr->system_client_id)
 645   {
 646     log_info("system client port appeared");
 647
 648     if (!is_input)
 649     { /* output capture port */
 650
 651       vclient = ladish_graph_find_client_by_uuid(vgraph, g_system_capture_uuid);
 652       if (vclient == NULL)
 653       {
 654         if (!ladish_client_create(g_system_capture_uuid, &vclient))
 655         {
 656           log_error("ladish_client_create() failed.");
 657           goto free_alsa_names;
 658         }
 659
 660         if (!ladish_graph_add_client(vgraph, vclient, "Hardware Capture", false))
 661         {
 662           log_error("ladish_graph_add_client() failed.");
 663           ladish_client_destroy(vclient);
 664           goto free_alsa_names;
 665         }
 666       }
 667     }
 668     else
 669     { /* input playback port */
 670       vclient = ladish_graph_find_client_by_uuid(vgraph, g_system_playback_uuid);
 671       if (vclient == NULL)
 672       {
 673         if (!ladish_client_create(g_system_playback_uuid, &vclient))
 674         {
 675           log_error("ladish_client_create() failed.");
 676           goto free_alsa_names;
 677         }
 678
 679         if (!ladish_graph_add_client(vgraph, vclient, "Hardware Playback", false))
 680         {
 681           ladish_client_destroy(vclient);
 682           goto free_alsa_names;
 683         }
 684       }
 685     }
 686   }
 687   else
 688   { /* non-system client */
 689     log_info("non-system client port appeared");
 690
 691     if (ladish_client_get_interlink(jack_client, vclient_uuid))
 692     {
 693       vclient = ladish_graph_find_client_by_uuid(vgraph, vclient_uuid);
 694       ASSERT(vclient != NULL);
 695     }
 696     else
 697     {
 698       log_info("creating new vclient");
 699       if (!ladish_client_create(NULL, &vclient))
 700       {
 701         log_error("ladish_client_create() failed.");
 702         goto free_alsa_names;
 703       }
 704
 705       ladish_client_interlink(vclient, jack_client);
 706
 707       if (has_app)
 708       {
 709         ladish_client_set_app(vclient, app_uuid);
 710       }
 711
 712       if (!ladish_graph_add_client(vgraph, vclient, jack_client_name, false))
 713       {
 714         log_error("ladish_graph_add_client() failed to add client '%s' to virtual graph", jack_client_name);
 715         ladish_client_destroy(vclient);
 716         goto free_alsa_names;
 717       }
 718     }
 719   }
 720
 721   /********************/
 722   /* add newly appeared port to the virtual graph */
 723
 724   if (is_a2j)
 725   {
 726     vport_name = alsa_port_name;
 727   }
 728   else
 729   {
 730     vport_name = jack_port_name;
 731   }
 732
 733   if (!ladish_graph_add_port(vgraph, vclient, port, vport_name, type, flags, false))
 734   {
 735     log_error("ladish_graph_add_port() failed.");
 736     goto free_alsa_names;
 737   }
 738
 739 free_alsa_names:
 740   if (a2j_fake_jack_port_name != NULL)
 741   {
 742     free(a2j_fake_jack_port_name);
 743   }
 744
 745   if (is_a2j)
 746   {
 747     free(alsa_client_name);
 748     free(alsa_port_name);
 749   }
 750
 751 exit:
 752   return;
 753 }
 754
 755 static void port_disappeared(void * context, uint64_t client_id, uint64_t port_id)
 756 {
 757   ladish_client_handle jclient;
 758   ladish_client_handle vclient;
 759   ladish_port_handle port;
 760   ladish_graph_handle vgraph;
 761   bool jmcore;
 762
 763   log_info("port_disappeared(%"PRIu64", %"PRIu64")", client_id, port_id);
 764
 765   jclient = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, client_id);
 766   if (jclient == NULL)
 767   {
 768     log_error("Port of unknown JACK client with id %"PRIu64" disappeared", client_id);
 769     return;
 770   }
 771
 772   port = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
 773   if (port == NULL)
 774   {
 775     log_error("Unknown JACK port with id %"PRIu64" disappeared", port_id);
 776     return;
 777   }
 778
 779   /* find the virtual graph that owns the app that owns the client that owns the disappeared port */
 780   jmcore = false;
 781   vgraph = ladish_client_get_vgraph(jclient);
 782   if (vgraph == NULL)
 783   {
 784     vgraph = find_link_port_vgraph_by_uuid(virtualizer_ptr, ladish_graph_get_port_name(virtualizer_ptr->jack_graph, port), NULL);
 785     if (vgraph == NULL)
 786     {
 787       log_error("Cannot find vgraph for disappeared jmcore port");
 788       ASSERT_NO_PASS;
 789       return;
 790     }
 791
 792     jmcore = true;
 793     ladish_graph_remove_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
 794   }
 795
 796   if (ladish_graph_is_persist(vgraph)) /* if port is supposed to be persisted */
 797   {
 798     if (!jmcore)
 799     {
 800       ladish_port_set_jack_id(port, 0);
 801       ladish_graph_hide_port(virtualizer_ptr->jack_graph, port);
 802     }
 803     if (vgraph != NULL)
 804     {
 805       ladish_graph_hide_port(vgraph, port);
 806       vclient = ladish_graph_get_port_client(vgraph, port);
 807       if (ladish_graph_client_looks_empty(vgraph, vclient))
 808       {
 809         ladish_graph_hide_client(vgraph, vclient);
 810       }
 811     }
 812   }
 813   else
 814   {
 815     if (!jmcore)
 816     {
 817       ladish_graph_remove_port(virtualizer_ptr->jack_graph, port);
 818     }
 819
 820     if (vgraph != NULL)
 821     {
 822       vclient = ladish_graph_remove_port(vgraph, port);
 823       if (vclient != NULL)
 824       {
 825         if (ladish_graph_client_is_empty(vgraph, vclient))
 826         {
 827           ladish_graph_remove_client(vgraph, vclient);
 828           ladish_client_clear_interlink(jclient);
 829         }
 830       }
 831     }
 832   }
 833 }
 834
 835 static void port_renamed(void * context, uint64_t client_id, uint64_t port_id, const char * old_port_name, const char * new_port_name)
 836 {
 837   ladish_client_handle client;
 838   ladish_port_handle port;
 839   ladish_graph_handle vgraph;
 840
 841   log_info("port_renamed(%"PRIu64", '%s', '%s')", port_id, old_port_name, new_port_name);
 842
 843   client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, client_id);
 844   if (client == NULL)
 845   {
 846     log_error("Port of unknown JACK client with id %"PRIu64" was renamed", client_id);
 847     return;
 848   }
 849
 850   /* find the virtual graph that owns the app that owns the client that owns the renamed port */
 851   vgraph = ladish_client_get_vgraph(client);
 852
 853   port = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
 854   if (port == NULL)
 855   {
 856     log_error("Unknown JACK port with id %"PRIu64" was renamed", port_id);
 857     return;
 858   }
 859
 860   if (!ladish_graph_rename_port(virtualizer_ptr->jack_graph, port, new_port_name))
 861   {
 862     log_error("renaming of port in jack graph failed");
 863   }
 864
 865   if (!ladish_graph_rename_port(vgraph, port, new_port_name))
 866   {
 867     log_error("renaming of port in virtual graph failed");
 868   }
 869 }
 870
 871 static bool ports_connect_request(void * context, ladish_graph_handle graph_handle, ladish_port_handle port1, ladish_port_handle port2)
 872 {
 873   uint64_t port1_id;
 874   uint64_t port2_id;
 875
 876   ASSERT(ladish_graph_get_opath(graph_handle)); /* studio or room virtual graph */
 877   log_info("virtualizer: ports connect request");
 878
 879   if (graph_handle == g_studio.studio_graph)
 880   {
 881     port1_id = ladish_port_get_jack_id(port1);
 882     port2_id = ladish_port_get_jack_id(port2);
 883   }
 884   else
 885   {
 886     port1_id = ladish_port_get_jack_id_room(port1);
 887     port2_id = ladish_port_get_jack_id_room(port2);
 888   }
 889
 890   return graph_proxy_connect_ports(virtualizer_ptr->jack_graph_proxy, port1_id, port2_id);
 891 }
 892
 893 static bool ports_disconnect_request(void * context, ladish_graph_handle graph_handle, uint64_t connection_id)
 894 {
 895   ladish_port_handle port1;
 896   ladish_port_handle port2;
 897   uint64_t port1_id;
 898   uint64_t port2_id;
 899
 900   ASSERT(ladish_graph_get_opath(graph_handle)); /* studio or room virtual graph */
 901   log_info("virtualizer: ports disconnect request");
 902
 903   if (!ladish_graph_get_connection_ports(graph_handle, connection_id, &port1, &port2))
 904   {
 905     log_error("cannot find ports that are disconnect-requested");
 906     ASSERT_NO_PASS;
 907     return false;
 908   }
 909
 910   if (graph_handle == g_studio.studio_graph)
 911   {
 912     port1_id = ladish_port_get_jack_id(port1);
 913     port2_id = ladish_port_get_jack_id(port2);
 914   }
 915   else
 916   {
 917     port1_id = ladish_port_get_jack_id_room(port1);
 918     port2_id = ladish_port_get_jack_id_room(port2);
 919   }
 920
 921   return graph_proxy_disconnect_ports(virtualizer_ptr->jack_graph_proxy, port1_id, port2_id);
 922 }
 923
 924 static void ports_connected(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id)
 925 {
 926   ladish_port_handle port1;
 927   ladish_port_handle port2;
 928   uint64_t connection_id;
 929   ladish_graph_handle vgraph1;
 930   ladish_graph_handle vgraph2;
 931
 932   log_info("ports_connected %"PRIu64":%"PRIu64" %"PRIu64":%"PRIu64"", client1_id, port1_id, client2_id, port2_id);
 933
 934   if (!lookup_port(virtualizer_ptr, port1_id, &port1, &vgraph1))
 935   {
 936     return;
 937   }
 938
 939   if (!lookup_port(virtualizer_ptr, port2_id, &port2, &vgraph2))
 940   {
 941     return;
 942   }
 943
 944   if (vgraph1 != vgraph2)
 945   {
 946     /* TODO */
 947     log_error("ignoring connection with endpoints in different vgraphs");
 948     return;
 949   }
 950
 951   ladish_graph_add_connection(virtualizer_ptr->jack_graph, port1, port2, false);
 952
 953   if (ladish_graph_find_connection(vgraph1, port1, port2, &connection_id))
 954   {
 955     log_info("showing hidden virtual connection");
 956     ladish_graph_show_connection(vgraph1, connection_id);
 957   }
 958   else
 959   {
 960     log_info("creating new virtual connection");
 961     ladish_graph_add_connection(vgraph1, port1, port2, false);
 962   }
 963 }
 964
 965 static void ports_disconnected(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id)
 966 {
 967   ladish_port_handle port1;
 968   ladish_port_handle port2;
 969   uint64_t connection_id;
 970   ladish_graph_handle vgraph1;
 971   ladish_graph_handle vgraph2;
 972
 973   log_info("ports_disconnected %"PRIu64":%"PRIu64" %"PRIu64":%"PRIu64"", client1_id, port1_id, client2_id, port2_id);
 974
 975   if (!lookup_port(virtualizer_ptr, port1_id, &port1, &vgraph1))
 976   {
 977     return;
 978   }
 979
 980   if (!lookup_port(virtualizer_ptr, port2_id, &port2, &vgraph2))
 981   {
 982     return;
 983   }
 984
 985   if (vgraph1 != vgraph2)
 986   {
 987     /* TODO */
 988     log_error("ignoring connection with endpoints in different vgraphs");
 989     return;
 990   }
 991
 992   if (ladish_graph_find_connection(virtualizer_ptr->jack_graph, port1, port2, &connection_id))
 993   {
 994     ladish_graph_remove_connection(virtualizer_ptr->jack_graph, connection_id, true);
 995   }
 996   else
 997   {
 998     log_error("ports %"PRIu64":%"PRIu64" and %"PRIu64":%"PRIu64" are not connected in the JACK graph", client1_id, port1_id, client2_id, port2_id);
 999   }
1000
1001   if (ladish_graph_find_connection(vgraph1, port1, port2, &connection_id))
1002   {
1003     ladish_graph_remove_connection(vgraph1, connection_id, false);
1004   }
1005   else
1006   {
1007     log_error("ports %"PRIu64":%"PRIu64" and %"PRIu64":%"PRIu64" are not connected in the virtual graph", client1_id, port1_id, client2_id, port2_id);
1008   }
1009 }
1010
1011 #undef virtualizer_ptr
1012
1013 bool
1014 ladish_virtualizer_create(
1015   graph_proxy_handle jack_graph_proxy,
1016   ladish_graph_handle jack_graph,
1017   ladish_virtualizer_handle * handle_ptr)
1018 {
1019   struct virtualizer * virtualizer_ptr;
1020
1021   virtualizer_ptr = malloc(sizeof(struct virtualizer));
1022   if (virtualizer_ptr == NULL)
1023   {
1024     log_error("malloc() failed for struct virtualizer");
1025     return false;
1026   }
1027
1028   virtualizer_ptr->jack_graph_proxy = jack_graph_proxy;
1029   virtualizer_ptr->jack_graph = jack_graph;
1030   virtualizer_ptr->system_client_id = 0;
1031   virtualizer_ptr->our_clients_count = 0;
1032
1033   if (!graph_proxy_attach(
1034         jack_graph_proxy,
1035         virtualizer_ptr,
1036         clear,
1037         client_appeared,
1038         NULL,                   /* jackdbus does not have client rename functionality (yet) */
1039         client_disappeared,
1040         port_appeared,
1041         port_renamed,
1042         port_disappeared,
1043         ports_connected,
1044         ports_disconnected))
1045   {
1046     free(virtualizer_ptr);
1047     return false;
1048   }
1049
1050   *handle_ptr = (ladish_virtualizer_handle)virtualizer_ptr;
1051   return true;
1052 }
1053
1054 #define virtualizer_ptr ((struct virtualizer *)handle)
1055
1056 void
1057 ladish_virtualizer_set_graph_connection_handlers(
1058   ladish_virtualizer_handle handle,
1059   ladish_graph_handle graph)
1060 {
1061   ladish_graph_set_connection_handlers(graph, virtualizer_ptr, ports_connect_request, ports_disconnect_request);
1062 }
1063
1064 unsigned int
1065 ladish_virtualizer_get_our_clients_count(
1066   ladish_virtualizer_handle handle)
1067 {
1068   return virtualizer_ptr->our_clients_count;
1069 }
1070
1071 bool
1072 ladish_virtualizer_is_hidden_app(
1073   ladish_graph_handle jack_graph,
1074   const uuid_t app_uuid,
1075   const char * app_name)
1076 {
1077   ladish_client_handle jclient;
1078   ladish_graph_handle vgraph;
1079   uuid_t vclient_uuid;
1080   ladish_client_handle vclient;
1081   bool is_empty;
1082   uuid_t jclient_uuid;
1083   bool is_a2j;
1084
1085   //ladish_graph_dump(g_studio.jack_graph);
1086
1087   jclient = ladish_graph_find_client_by_app(jack_graph, app_uuid);
1088   if (jclient == NULL)
1089   {
1090     log_info("App without JACK client is treated as hidden one");
1091     return true;
1092   }
1093
1094   ladish_client_get_uuid(jclient, jclient_uuid);
1095   is_a2j = uuid_compare(jclient_uuid, g_a2j_uuid) == 0;
1096   is_empty = ladish_graph_client_is_empty(jack_graph, jclient);
1097
1098   vgraph = ladish_client_get_vgraph(jclient);
1099   if (vgraph == NULL)
1100   {
1101     ASSERT_NO_PASS;
1102     return true;
1103   }
1104
1105   //ladish_graph_dump(vgraph);
1106
1107   if (!ladish_graph_client_looks_empty(jack_graph, jclient) ||
1108       !ladish_graph_client_is_hidden(jack_graph, jclient))
1109   {
1110     return false;
1111   }
1112
1113   if (is_a2j)
1114   {
1115     /* The a2j jclient has no interlinked vclient */
1116     return true;
1117   }
1118
1119   if (!ladish_client_get_interlink(jclient, vclient_uuid))
1120   {
1121     if (is_empty)
1122     {
1123       log_info("jack client of app '%s' has no interlinked vgraph client and no ports", app_name);
1124     }
1125     else
1126     {
1127       log_error("jack client of app '%s' has no interlinked vgraph client", app_name);
1128       ASSERT_NO_PASS;
1129     }
1130     return true;
1131   }
1132
1133   vclient = ladish_graph_find_client_by_uuid(vgraph, vclient_uuid);
1134   if (vclient == NULL)
1135   {
1136     ASSERT_NO_PASS;
1137     return true;
1138   }
1139
1140   if (!ladish_graph_client_looks_empty(vgraph, vclient))
1141   {
1142     return false;
1143   }
1144
1145   ASSERT(ladish_graph_client_is_hidden(vgraph, vclient)); /* vclients are automatically hidden when they start looking empty (on port disappear) */
1146   return true;
1147 }
1148
1149 void
1150 ladish_virtualizer_remove_app(
1151   ladish_graph_handle jack_graph,
1152   const uuid_t app_uuid,
1153   const char * app_name)
1154 {
1155   ladish_client_handle jclient;
1156   ladish_graph_handle vgraph;
1157   uuid_t vclient_uuid;
1158   ladish_client_handle vclient;
1159   bool is_empty;
1160   uuid_t jclient_uuid;
1161   bool is_a2j;
1162
1163   //ladish_graph_dump(g_studio.jack_graph);
1164
1165   jclient = ladish_graph_find_client_by_app(jack_graph, app_uuid);
1166   if (jclient == NULL)
1167   {
1168     log_info("removing app without JACK client");
1169     return;
1170   }
1171
1172   ladish_client_get_uuid(jclient, jclient_uuid);
1173   is_a2j = uuid_compare(jclient_uuid, g_a2j_uuid) == 0;
1174   is_empty = ladish_graph_client_is_empty(jack_graph, jclient);
1175
1176   vgraph = ladish_client_get_vgraph(jclient);
1177   if (vgraph == NULL)
1178   {
1179     ASSERT_NO_PASS;
1180     return;
1181   }
1182
1183   //ladish_graph_dump(vgraph);
1184
1185   ladish_graph_remove_client(jack_graph, jclient);
1186
1187   if (is_a2j)
1188   {
1189     /* The a2j jclient has no interlinked vclient */
1190     return;
1191   }
1192
1193   if (!ladish_client_get_interlink(jclient, vclient_uuid))
1194   {
1195     if (is_empty)
1196     {
1197       /* jack client without ports and thus without vgraph client */
1198       return;
1199     }
1200
1201     log_error("jack client of app '%s' has no interlinked vgraph client", app_name);
1202     ladish_graph_dump(g_studio.jack_graph);
1203     ladish_graph_dump(vgraph);
1204     ASSERT_NO_PASS;
1205     return;
1206   }
1207
1208   vclient = ladish_graph_find_client_by_uuid(vgraph, vclient_uuid);
1209   if (vclient == NULL)
1210   {
1211     ASSERT_NO_PASS;
1212     return;
1213   }
1214
1215   ladish_graph_remove_client(vgraph, vclient);
1216   ladish_graph_dump(g_studio.jack_graph);
1217   ladish_graph_dump(vgraph);
1218 }
1219
1220 void
1221 ladish_virtualizer_destroy(
1222   ladish_virtualizer_handle handle)
1223 {
1224   log_info("ladish_virtualizer_destroy() called");
1225
1226   graph_proxy_detach((graph_proxy_handle)handle, virtualizer_ptr);
1227   free(virtualizer_ptr);
1228 }
1229
1230 #undef virtualizer_ptr
1231
1232 #define vgraph ((ladish_graph_handle)vgraph_context)
1233 void
1234 ladish_virtualizer_rename_app(
1235   void * vgraph_context,
1236   const uuid_t uuid,
1237   const char * old_name,
1238   const char * new_app_name)
1239 {
1240   ladish_client_handle client;
1241
1242   client = ladish_graph_find_client_by_app(vgraph, uuid);
1243   if (client != NULL)
1244   {
1245     ladish_graph_rename_client(vgraph, client, new_app_name);
1246   }
1247
1248   client = ladish_graph_find_client_by_app(g_studio.jack_graph, uuid);
1249   if (client != NULL)
1250   {
1251     ladish_graph_rename_client(g_studio.jack_graph, client, new_app_name);
1252   }
1253 }
1254 #undef vgraph
1255
1256 bool
1257 ladish_virtualizer_is_system_client(
1258   uuid_t uuid)
1259 {
1260   if (uuid_compare(uuid, g_system_capture_uuid) == 0)
1261   {
1262     return true;
1263   }
1264
1265   if (uuid_compare(uuid, g_system_playback_uuid) == 0)
1266   {
1267     return true;
1268   }
1269
1270   return false;
1271 }