a2jmidid.c

   1 /*
   2  * ALSA SEQ < - > JACK MIDI bridge
   3  *
   4  * Copyright (c) 2006,2007 Dmitry S. Baikov <c0ff@konstruktiv.org>
   5  * Copyright (c) 2007,2008,2009,2011 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; version 2 of the License.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <signal.h>
  24 #include <semaphore.h>
  25 #include <stdbool.h>
  26 #include <sys/stat.h>
  27 #include <pthread.h>
  28
  29 #include <alsa/asoundlib.h>
  30
  31 #include <jack/jack.h>
  32 #include <jack/midiport.h>
  33 #include <jack/ringbuffer.h>
  34
  35 #if HAVE_DBUS_1
  36 # include <dbus/dbus.h>
  37 #endif
  38
  39 #include <getopt.h>
  40
  41 #include "list.h"
  42 #include "structs.h"
  43 #include "port.h"
  44 #include "port_thread.h"
  45 #include "port_hash.h"
  46 #include "log.h"
  47 #if HAVE_DBUS_1
  48 # include "dbus.h"
  49 #endif
  50 #include "a2jmidid.h"
  51 #include "paths.h"
  52 #include "conf.h"
  53 #include "jack.h"
  54 #include "sigsegv.h"
  55 #include "gitversion.h"
  56 #include "dbus_iface_control.h"
  57
  58 #define MAIN_LOOP_SLEEP_INTERVAL 50 // in milliseconds
  59
  60 bool g_keep_walking = true;
  61 bool g_keep_alsa_walking = false;
  62 bool g_stop_request = false;
  63 static bool g_started = false;
  64 struct a2j * g_a2j = NULL;
  65 size_t g_max_jack_port_name_size;
  66 bool g_disable_port_uniqueness = false;
  67
  68 bool g_a2j_export_hw_ports = false;
  69 char * g_a2j_jack_server_name = "default";
  70
  71 static
  72 void
  73 a2j_sigint_handler(
  74   int i)
  75 {
  76   g_keep_walking = false;
  77 }
  78
  79 static
  80 bool
  81 a2j_stream_init(
  82   struct a2j * self,
  83   int dir)
  84 {
  85   struct a2j_stream *str = &self->stream[dir];
  86
  87   str->new_ports = jack_ringbuffer_create(MAX_PORTS * sizeof(struct a2j_port *));
  88   if (str->new_ports == NULL)
  89   {
  90     return false;
  91   }
  92
  93   snd_midi_event_new(MAX_EVENT_SIZE, &str->codec);
  94   INIT_LIST_HEAD(&str->list);
  95
  96   return true;
  97 }
  98
  99 static
 100 void
 101 a2j_stream_attach(
 102   struct a2j_stream * stream_ptr)
 103 {
 104 }
 105
 106 static
 107 void
 108 a2j_stream_detach(
 109   struct a2j_stream * stream_ptr)
 110 {
 111   struct a2j_port * port_ptr;
 112   struct list_head * node_ptr;
 113
 114   while (!list_empty(&stream_ptr->list))
 115   {
 116     node_ptr = stream_ptr->list.next;
 117     list_del(node_ptr);
 118     port_ptr = list_entry(node_ptr, struct a2j_port, siblings);
 119     a2j_info("port deleted: %s", port_ptr->name);
 120     a2j_port_free(port_ptr);
 121   }
 122 }
 123
 124 static
 125 void
 126 a2j_stream_close(
 127   struct a2j * self,
 128   int dir)
 129 {
 130   struct a2j_stream *str = &self->stream[dir];
 131
 132   if (str->codec)
 133     snd_midi_event_free(str->codec);
 134   if (str->new_ports)
 135     jack_ringbuffer_free(str->new_ports);
 136 }
 137
 138 struct a2j * a2j_new(void)
 139 {
 140   int error;
 141   void * thread_status;
 142
 143   struct a2j *self = calloc(1, sizeof(struct a2j));
 144   a2j_debug("midi: new");
 145   if (!self)
 146   {
 147     a2j_error("calloc() failed to allocate a2j struct");
 148     goto fail;
 149   }
 150
 151   self->port_add = jack_ringbuffer_create(2 * MAX_PORTS * sizeof(snd_seq_addr_t));
 152   if (self->port_add == NULL)
 153   {
 154     goto free_self;
 155   }
 156
 157   self->port_del = jack_ringbuffer_create(2 * MAX_PORTS * sizeof(struct a2j_port *));
 158   if (self->port_del == NULL)
 159   {
 160     goto free_ringbuffer_add;
 161   }
 162
 163   self->outbound_events = jack_ringbuffer_create(MAX_EVENT_SIZE * 16 * sizeof(struct a2j_delivery_event));
 164   if (self->outbound_events == NULL)
 165   {
 166     goto free_ringbuffer_del;
 167   }
 168
 169   if (!a2j_stream_init(self, A2J_PORT_CAPTURE))
 170   {
 171     goto free_ringbuffer_outbound;
 172   }
 173
 174   if (!a2j_stream_init(self, A2J_PORT_PLAYBACK))
 175   {
 176     goto close_capture_stream;
 177   }
 178
 179   error = snd_seq_open(&self->seq, "hw", SND_SEQ_OPEN_DUPLEX, 0);
 180   if (error < 0)
 181   {
 182     a2j_error("failed to open alsa seq");
 183     goto close_playback_stream;
 184   }
 185
 186   error = snd_seq_set_client_name(self->seq, "a2jmidid");
 187   if (error < 0)
 188   {
 189     a2j_error("snd_seq_set_client_name() failed");
 190     goto close_seq_client;
 191   }
 192
 193   self->port_id = snd_seq_create_simple_port(
 194     self->seq,
 195     "port",
 196     SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_WRITE
 197 #ifndef DEBUG
 198     |SND_SEQ_PORT_CAP_NO_EXPORT
 199 #endif
 200     ,SND_SEQ_PORT_TYPE_APPLICATION);
 201   if (self->port_id < 0)
 202   {
 203     a2j_error("snd_seq_create_simple_port() failed");
 204     goto close_seq_client;
 205   }
 206
 207   self->client_id = snd_seq_client_id(self->seq);
 208   if (self->client_id < 0)
 209   {
 210     a2j_error("snd_seq_client_id() failed");
 211     goto close_seq_client;
 212   }
 213
 214   self->queue = snd_seq_alloc_queue(self->seq);
 215   if (self->queue < 0)
 216   {
 217     a2j_error("snd_seq_alloc_queue() failed");
 218     goto close_seq_client;
 219   }
 220
 221   snd_seq_start_queue(self->seq, self->queue, 0);
 222
 223   a2j_stream_attach(self->stream + A2J_PORT_CAPTURE);
 224   a2j_stream_attach(self->stream + A2J_PORT_PLAYBACK);
 225
 226   error = snd_seq_nonblock(self->seq, 1);
 227   if (error < 0)
 228   {
 229     a2j_error("snd_seq_nonblock() failed");
 230     goto close_seq_client;
 231   }
 232
 233   snd_seq_drop_input(self->seq);
 234
 235   a2j_add_ports(&self->stream[A2J_PORT_CAPTURE]);
 236   a2j_add_ports(&self->stream[A2J_PORT_PLAYBACK]);
 237
 238   self->jack_client = a2j_jack_client_create(self, A2J_JACK_CLIENT_NAME, g_a2j_jack_server_name);
 239   if (self->jack_client == NULL)
 240   {
 241     goto free_self;
 242   }
 243
 244   if (sem_init(&self->io_semaphore, 0, 0) < 0)
 245   {
 246     a2j_error("can't create IO semaphore");
 247     goto close_jack_client;
 248   }
 249
 250   if (jack_activate(self->jack_client))
 251   {
 252     a2j_error("can't activate jack client");
 253     goto sem_destroy;
 254   }
 255
 256   g_keep_alsa_walking = true;
 257
 258   if (pthread_create(&self->alsa_input_thread, NULL, a2j_alsa_input_thread, self) < 0)
 259   {
 260     a2j_error("cannot start ALSA input thread");
 261     goto sem_destroy;
 262   }
 263
 264   /* wake the poll loop in the alsa input thread so initial ports are fetched */
 265   error = snd_seq_connect_from(self->seq, self->port_id, SND_SEQ_CLIENT_SYSTEM, SND_SEQ_PORT_SYSTEM_ANNOUNCE);
 266   if (error < 0)
 267   {
 268     a2j_error("snd_seq_connect_from() failed");
 269     goto join_input_thread;
 270   }
 271
 272   if (pthread_create(&self->alsa_output_thread, NULL, a2j_alsa_output_thread, self) < 0)
 273   {
 274     a2j_error("cannot start ALSA output thread");
 275     goto disconnect;
 276   }
 277
 278   return self;
 279
 280 disconnect:
 281   g_keep_alsa_walking = false;  /* tell alsa threads to stop */
 282   snd_seq_disconnect_from(self->seq, self->port_id, SND_SEQ_CLIENT_SYSTEM, SND_SEQ_PORT_SYSTEM_ANNOUNCE);
 283 join_input_thread:
 284   pthread_join(self->alsa_input_thread, &thread_status);
 285 sem_destroy:
 286   sem_destroy(&self->io_semaphore);
 287 close_jack_client:
 288   error = jack_client_close(self->jack_client);
 289   if (error != 0)
 290   {
 291     a2j_error("Cannot close jack client");
 292   }
 293 close_seq_client:
 294   snd_seq_close(self->seq);
 295 close_playback_stream:
 296   a2j_stream_close(self, A2J_PORT_PLAYBACK);
 297 close_capture_stream:
 298   a2j_stream_close(self, A2J_PORT_CAPTURE);
 299 free_ringbuffer_outbound:
 300   jack_ringbuffer_free(self->outbound_events);
 301 free_ringbuffer_del:
 302   jack_ringbuffer_free(self->port_del);
 303 free_ringbuffer_add:
 304   jack_ringbuffer_free(self->port_add);
 305 free_self:
 306   free(self);
 307 fail:
 308   return NULL;
 309 }
 310
 311 static void a2j_destroy(struct a2j * self)
 312 {
 313   int error;
 314   void * thread_status;
 315
 316   a2j_debug("midi: delete");
 317
 318   g_keep_alsa_walking = false;  /* tell alsa threads to stop */
 319
 320   /* do something that we need to do anyway and will wake the input thread, then join */
 321   snd_seq_disconnect_from(self->seq, self->port_id, SND_SEQ_CLIENT_SYSTEM, SND_SEQ_PORT_SYSTEM_ANNOUNCE);
 322   pthread_join(self->alsa_input_thread, &thread_status);
 323
 324   /* wake output thread and join, then destroy the semaphore */
 325   sem_post(&self->io_semaphore);
 326   pthread_join(self->alsa_output_thread, &thread_status);
 327   sem_destroy(&self->io_semaphore);
 328
 329   jack_ringbuffer_reset(self->port_add);
 330
 331   jack_deactivate(self->jack_client);
 332
 333   a2j_stream_detach(self->stream + A2J_PORT_CAPTURE);
 334   a2j_stream_detach(self->stream + A2J_PORT_PLAYBACK);
 335
 336   error = jack_client_close(self->jack_client);
 337   if (error != 0)
 338   {
 339     a2j_error("Cannot close jack client (%d)", error);
 340   }
 341
 342   snd_seq_close(self->seq);
 343   self->seq = NULL;
 344
 345   a2j_stream_close(self, A2J_PORT_PLAYBACK);
 346   a2j_stream_close(self, A2J_PORT_CAPTURE);
 347
 348   jack_ringbuffer_free(self->outbound_events);
 349   jack_ringbuffer_free(self->port_add);
 350   jack_ringbuffer_free(self->port_del);
 351
 352   free(self);
 353 }
 354
 355 bool a2j_start(void)
 356 {
 357   if (g_started)
 358   {
 359     a2j_error("Bridge already started");
 360     return false;
 361   }
 362
 363   a2j_info("Bridge starting...");
 364
 365   a2j_info("Using JACK server '%s'", g_a2j_jack_server_name);
 366
 367   a2j_info("Hardware ports %s be exported.", g_a2j_export_hw_ports ? "will": "will not");
 368
 369   g_a2j = a2j_new();
 370   if (g_a2j == NULL)
 371   {
 372     a2j_error("a2j_new() failed.");
 373     return false;
 374   }
 375
 376   a2j_info("Bridge started");
 377
 378 #if HAVE_DBUS_1
 379   if (a2j_dbus_is_available())
 380   {
 381     a2j_dbus_signal_emit_bridge_started();
 382   }
 383 #endif
 384
 385   g_started = true;
 386
 387   return true;
 388 }
 389
 390 bool a2j_stop(void)
 391 {
 392   if (!g_started)
 393   {
 394     a2j_error("Bridge already stopped");
 395     return false;
 396   }
 397
 398   a2j_info("Bridge stopping...");
 399
 400   a2j_destroy(g_a2j);
 401   g_a2j = NULL;
 402
 403   a2j_info("Bridge stopped");
 404
 405   g_started = false;
 406
 407 #if HAVE_DBUS_1
 408   if (a2j_dbus_is_available())
 409   {
 410     a2j_dbus_signal_emit_bridge_stopped();
 411   }
 412 #endif
 413
 414   return true;
 415 }
 416
 417 bool
 418 a2j_is_started()
 419 {
 420   return g_started;
 421 }
 422
 423 static
 424 void
 425 a2j_help(
 426   const char * self)
 427 {
 428   a2j_info("Usage: %s [-j jack-server] [-e | --export-hw] [-u]", self);
 429   a2j_info("Defaults:");
 430   a2j_info("-j default");
 431 }
 432
 433 int
 434 main(
 435   int argc,
 436   char *argv[])
 437 {
 438   bool dbus;
 439   struct stat st;
 440   char timestamp_str[26];
 441
 442   //test_list_sort();
 443
 444   st.st_mtime = 0;
 445   stat(argv[0], &st);
 446   ctime_r(&st.st_mtime, timestamp_str);
 447   timestamp_str[24] = 0;
 448
 449   g_max_jack_port_name_size = jack_port_name_size();
 450
 451   if (!a2j_paths_init())
 452   {
 453     goto fail;
 454   }
 455
 456 #if HAVE_DBUS_1
 457   dbus = argc == 2 && strcmp(argv[1], "dbus") == 0;
 458 #else
 459   dbus = false;
 460 #endif
 461
 462   if (!a2j_log_init(dbus))
 463   {
 464     goto fail_paths_uninit;
 465   }
 466
 467   if (!dbus)
 468   {
 469     struct option long_opts[] = { { "export-hw", 0, 0, 'e' }, { 0, 0, 0, 0 } };
 470
 471     int option_index = 0;
 472     int c;
 473     while ((c = getopt_long(argc, argv, "j:eu", long_opts, &option_index)) != -1)
 474     {
 475       switch (c)
 476       {
 477       case 'j':
 478         g_a2j_jack_server_name = strdup(optarg);
 479         break;
 480       case 'e':
 481         g_a2j_export_hw_ports = true;
 482         break;
 483       case 'u':
 484         g_disable_port_uniqueness = true;
 485         break;
 486       default:
 487         a2j_help(argv[0]);
 488         return 1;
 489       }
 490     }
 491   }
 492   else
 493   {
 494     //a2j_conf_load();
 495   }
 496
 497   if (dbus)
 498   {
 499     a2j_info("----------------------------");
 500   }
 501
 502   a2j_info("JACK MIDI <-> ALSA sequencer MIDI bridge, version " A2J_VERSION " (" GIT_VERSION ") built on %s", timestamp_str);
 503   a2j_info("Copyright 2006,2007 Dmitry S. Baikov");
 504   a2j_info("Copyright 2007,2008,2009,2011 Nedko Arnaudov");
 505
 506   if (dbus)
 507   {
 508     a2j_info("----------------------------");
 509     a2j_info("Activated.");
 510   }
 511   else
 512   {
 513     a2j_info("");
 514   }
 515
 516   /* setup our SIGSEGV magic that prints nice stack in our logfile */
 517   if (dbus)
 518   {
 519     setup_sigsegv();
 520   }
 521
 522   signal(SIGINT, &a2j_sigint_handler);
 523   signal(SIGTERM, &a2j_sigint_handler);
 524
 525   if (dbus)
 526   {
 527 #if HAVE_DBUS_1
 528     if (!a2j_dbus_init())
 529     {
 530       a2j_error("a2j_dbus_init() failed.");
 531       goto fail_uninit_log;
 532     }
 533 #endif
 534   }
 535   else
 536   {
 537     if (!a2j_start())
 538     {
 539       goto fail_uninit_log;
 540     }
 541
 542     a2j_info("Press ctrl-c to stop the bridge");
 543   }
 544
 545   while (g_keep_walking)
 546   {
 547     if (dbus)
 548     {
 549 #if HAVE_DBUS_1
 550       if (!a2j_dbus_run(MAIN_LOOP_SLEEP_INTERVAL))
 551       {
 552         a2j_warning("Disconnect message was received from D-Bus.");
 553         break;
 554       }
 555 #endif
 556     }
 557     else
 558     {
 559       usleep(MAIN_LOOP_SLEEP_INTERVAL * 1000);
 560     }
 561
 562     if (g_stop_request)
 563     {
 564       g_stop_request = false;
 565
 566       a2j_stop();
 567
 568       if (!dbus)
 569       {
 570         break;
 571       }
 572     }
 573
 574     if (g_started)
 575     {
 576       a2j_free_ports(g_a2j->port_del);
 577       a2j_update_ports(g_a2j);
 578     }
 579   }
 580
 581   if (g_started)
 582   {
 583     a2j_stop();
 584   }
 585
 586 #if HAVE_DBUS_1
 587   if (dbus)
 588   {
 589     a2j_dbus_uninit();
 590
 591     a2j_info("Deactivated.");
 592     a2j_info("----------------------------");
 593   }
 594 #endif
 595
 596 fail_uninit_log:
 597   a2j_log_uninit();
 598
 599 fail_paths_uninit:
 600   a2j_paths_uninit();
 601
 602 fail:
 603   return 0;
 604 }