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