port_thread.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * ALSA SEQ < - > JACK MIDI bridge
   4  *
   5  * Copyright (c) 2006,2007 Dmitry S. Baikov <c0ff@konstruktiv.org>
   6  * Copyright (c) 2007,2008,2009 Nedko Arnaudov <nedko@arnaudov.name>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; version 2 of the License.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20  */
  21
  22 #include <stdbool.h>
  23 #include <semaphore.h>
  24 #include <alsa/asoundlib.h>
  25 #include <jack/jack.h>
  26 #include <jack/ringbuffer.h>
  27
  28 #include "list.h"
  29 #include "structs.h"
  30 #include "port.h"
  31 #include "port_hash.h"
  32 #include "log.h"
  33 #include "port_thread.h"
  34 #include "conf.h"
  35
  36 struct a2j_port *
  37 a2j_find_port_by_addr(
  38   struct a2j_stream * stream_ptr,
  39   snd_seq_addr_t addr)
  40 {
  41   struct list_head * node_ptr;
  42   struct a2j_port * port_ptr;
  43
  44   list_for_each(node_ptr, &stream_ptr->list)
  45   {
  46     port_ptr = list_entry(node_ptr, struct a2j_port, siblings);
  47     if (port_ptr->remote.client == addr.client && port_ptr->remote.port == addr.port)
  48     {
  49       return port_ptr;
  50     }
  51   }
  52
  53   return NULL;
  54 }
  55
  56 struct a2j_port *
  57 a2j_find_port_by_jack_port_name(
  58   struct a2j_stream * stream_ptr,
  59   const char * jack_port)
  60 {
  61   struct list_head * node_ptr;
  62   struct a2j_port * port_ptr;
  63
  64   list_for_each(node_ptr, &stream_ptr->list)
  65   {
  66     port_ptr = list_entry(node_ptr, struct a2j_port, siblings);
  67     if (strcmp(port_ptr->name, jack_port) == 0)
  68     {
  69       return port_ptr;
  70     }
  71   }
  72
  73   return NULL;
  74 }
  75
  76 /*
  77  * ==================== Port add/del handling thread ==============================
  78  */
  79 static
  80 void
  81 a2j_update_port_type(
  82   struct a2j * self,
  83   int type,
  84   snd_seq_addr_t addr,
  85   int caps,
  86   const snd_seq_port_info_t * info)
  87 {
  88   struct a2j_stream * stream_ptr;
  89   int alsa_mask;
  90   struct a2j_port * port_ptr;
  91
  92   a2j_debug("update_port_type(%d:%d)", addr.client, addr.port);
  93
  94   stream_ptr = &self->stream[type];
  95   port_ptr = a2j_find_port_by_addr(stream_ptr, addr);
  96
  97   if (type == A2J_PORT_CAPTURE)
  98   {
  99     alsa_mask = SND_SEQ_PORT_CAP_SUBS_READ;
 100   }
 101   else
 102   {
 103     alsa_mask = SND_SEQ_PORT_CAP_SUBS_WRITE;
 104   }
 105
 106   if (port_ptr != NULL && (caps & alsa_mask) != alsa_mask)
 107   {
 108     a2j_debug("setdead: %s", port_ptr->name);
 109     port_ptr->is_dead = true;
 110   }
 111
 112   if (port_ptr == NULL && (caps & alsa_mask) == alsa_mask)
 113   {
 114     if(jack_ringbuffer_write_space(stream_ptr->new_ports) >= sizeof(port_ptr)) {
 115       port_ptr = a2j_port_create(self, type, addr, info);
 116       if (port_ptr != NULL)
 117       {
 118         jack_ringbuffer_write(stream_ptr->new_ports, (char *)&port_ptr, sizeof(port_ptr));
 119       }
 120     } else {
 121       a2j_error( "dropping new port event... increase MAX_PORTS" );
 122     }
 123   }
 124 }
 125
 126 void
 127 a2j_update_port(
 128   struct a2j * self,
 129   snd_seq_addr_t addr,
 130   const snd_seq_port_info_t * info)
 131 {
 132   unsigned int port_caps = snd_seq_port_info_get_capability(info);
 133   unsigned int port_type = snd_seq_port_info_get_type(info);
 134
 135   a2j_debug("port %u:%u", addr.client, addr.port);
 136   a2j_debug("port type: 0x%08X", port_type);
 137   a2j_debug("port caps: 0x%08X", port_caps);
 138
 139   if (port_type & SND_SEQ_PORT_TYPE_SPECIFIC)
 140   {
 141     a2j_debug("SPECIFIC");
 142   }
 143
 144   if (port_type & SND_SEQ_PORT_TYPE_MIDI_GENERIC)
 145   {
 146     a2j_debug("MIDI_GENERIC");
 147   }
 148
 149   if (port_type & SND_SEQ_PORT_TYPE_MIDI_GM)
 150   {
 151     a2j_debug("MIDI_GM");
 152   }
 153
 154   if (port_type & SND_SEQ_PORT_TYPE_MIDI_GS)
 155   {
 156     a2j_debug("MIDI_GS");
 157   }
 158
 159   if (port_type & SND_SEQ_PORT_TYPE_MIDI_XG)
 160   {
 161     a2j_debug("MIDI_XG");
 162   }
 163
 164   if (port_type & SND_SEQ_PORT_TYPE_MIDI_MT32)
 165   {
 166     a2j_debug("MIDI_MT32");
 167   }
 168
 169   if (port_type & SND_SEQ_PORT_TYPE_MIDI_GM2)
 170   {
 171     a2j_debug("MIDI_GM2");
 172   }
 173
 174   if (port_type & SND_SEQ_PORT_TYPE_SYNTH)
 175   {
 176     a2j_debug("SYNTH");
 177   }
 178
 179   if (port_type & SND_SEQ_PORT_TYPE_DIRECT_SAMPLE)
 180   {
 181     a2j_debug("DIRECT_SAMPLE");
 182   }
 183
 184   if (port_type & SND_SEQ_PORT_TYPE_SAMPLE)
 185   {
 186     a2j_debug("SAMPLE");
 187   }
 188
 189   if (port_type & SND_SEQ_PORT_TYPE_HARDWARE)
 190   {
 191     a2j_debug("HARDWARE");
 192   }
 193
 194   if (port_type & SND_SEQ_PORT_TYPE_SOFTWARE)
 195   {
 196     a2j_debug("SOFTWARE");
 197   }
 198
 199   if (port_type & SND_SEQ_PORT_TYPE_SYNTHESIZER)
 200   {
 201     a2j_debug("SYNTHESIZER");
 202   }
 203
 204   if (port_type & SND_SEQ_PORT_TYPE_PORT)
 205   {
 206     a2j_debug("PORT");
 207   }
 208
 209   if (port_type & SND_SEQ_PORT_TYPE_APPLICATION)
 210   {
 211     a2j_debug("APPLICATION");
 212   }
 213
 214   if (port_type == 0)
 215   {
 216     a2j_debug("Ignoring port of type 0");
 217     return;
 218   }
 219
 220   if ((port_type & SND_SEQ_PORT_TYPE_HARDWARE) && !g_a2j_export_hw_ports)
 221   {
 222     a2j_debug("Ignoring hardware port");
 223     return;
 224   }
 225
 226   if (port_caps & SND_SEQ_PORT_CAP_NO_EXPORT)
 227   {
 228     a2j_debug("Ignoring no-export port");
 229     return;
 230   }
 231
 232   a2j_update_port_type(self, A2J_PORT_CAPTURE, addr, port_caps, info);
 233   a2j_update_port_type(self, A2J_PORT_PLAYBACK, addr, port_caps, info);
 234 }
 235
 236 void
 237 a2j_free_ports(
 238   jack_ringbuffer_t * ports)
 239 {
 240   struct a2j_port *port;
 241   int sz;
 242   while ((sz = jack_ringbuffer_read(ports, (char*)&port, sizeof(port)))) {
 243     assert (sz == sizeof(port));
 244     a2j_info("port deleted: %s", port->name);
 245     list_del(&port->siblings);
 246     a2j_port_free(port);
 247   }
 248 }
 249
 250 void
 251 a2j_update_ports(
 252   struct a2j * self)
 253 {
 254   snd_seq_addr_t addr;
 255   int size;
 256
 257   while ((size = jack_ringbuffer_read(self->port_add, (char *)&addr, sizeof(addr))) != 0)
 258   {
 259     snd_seq_port_info_t * info;
 260     int err;
 261
 262     snd_seq_port_info_alloca(&info);
 263     assert(size == sizeof(addr));
 264     assert(addr.client != self->client_id);
 265     if ((err = snd_seq_get_any_port_info(self->seq, addr.client, addr.port, info)) >= 0)
 266     {
 267       a2j_update_port(self, addr, info);
 268     }
 269     else
 270     {
 271       //a2j_port_setdead(self->stream[A2J_PORT_CAPTURE].ports, addr);
 272       //a2j_port_setdead(self->stream[A2J_PORT_PLAYBACK].ports, addr);
 273     }
 274   }
 275 }