apps/plugins/pdbox/PDa/src/s_midi_oss.c

   1 /* Copyright (c) 1997-1999 Guenter Geiger, Miller Puckette, Larry Troxler,
   2 * Winfried Ritsch, Karl MacMillan, and others.
   3 * For information on usage and redistribution, and for a DISCLAIMER OF ALL
   4 * WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */
   5
   6 /* MIDI I/O for Linux using OSS */
   7
   8 #include <stdio.h>
   9 #ifdef UNIX
  10 #include <unistd.h>
  11 #endif
  12 #include <stdlib.h>
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <fcntl.h>
  16 #include <errno.h>
  17 #include "m_pd.h"
  18 #include "s_stuff.h"
  19
  20 static int oss_nmidiin;
  21 static int oss_midiinfd[MAXMIDIINDEV];
  22 static int oss_nmidiout;
  23 static int oss_midioutfd[MAXMIDIOUTDEV];
  24
  25 static void oss_midiout(int fd, int n)
  26 {
  27     char b = n;
  28     if ((write(fd, (char *) &b, 1)) != 1)
  29         perror("midi write");
  30 }
  31
  32 #define O_MIDIFLAG O_NDELAY
  33
  34 void sys_do_open_midi(int nmidiin, int *midiinvec,
  35     int nmidiout, int *midioutvec)
  36 {
  37     int i;
  38     for (i = 0; i < nmidiout; i++)
  39         oss_midioutfd[i] = -1;
  40     for (i = 0, oss_nmidiin = 0; i < nmidiin; i++)
  41     {
  42         int fd = -1, j, outdevindex = -1;
  43         char namebuf[80];
  44         int devno = midiinvec[i];
  45
  46         for (j = 0; j < nmidiout; j++)
  47             if (midioutvec[j] == midiinvec[i])
  48                 outdevindex = j;
  49
  50             /* try to open the device for read/write. */
  51         if (devno == 0 && fd < 0 && outdevindex >= 0)
  52         {
  53             sys_setalarm(1000000);
  54             fd = open("/dev/midi", O_RDWR | O_MIDIFLAG);
  55             if (sys_verbose)
  56                 fprintf(stderr,
  57                     "device 1: tried /dev/midi READ/WRITE; returned %d\n", fd);
  58             if (outdevindex >= 0 && fd >= 0)
  59                 oss_midioutfd[outdevindex] = fd;
  60         }
  61         if (fd < 0 && outdevindex >= 0)
  62         {
  63             sys_setalarm(1000000);
  64             sprintf(namebuf, "/dev/midi%2.2d", devno);
  65             fd = open(namebuf, O_RDWR | O_MIDIFLAG);
  66             if (sys_verbose)
  67                 fprintf(stderr,
  68                     "device %d: tried %s READ/WRITE; returned %d\n",
  69                         devno, namebuf, fd);
  70             if (outdevindex >= 0 && fd >= 0)
  71                 oss_midioutfd[outdevindex] = fd;
  72         }
  73         if (fd < 0 && outdevindex >= 0)
  74         {
  75             sys_setalarm(1000000);
  76             sprintf(namebuf, "/dev/midi%d", devno);
  77             fd = open(namebuf, O_RDWR | O_MIDIFLAG);
  78             if (sys_verbose)
  79                 fprintf(stderr, "device %d: tried %s READ/WRITE; returned %d\n",
  80                     devno, namebuf, fd);
  81             if (outdevindex >= 0 && fd >= 0)
  82                 oss_midioutfd[outdevindex] = fd;
  83         }
  84         if (devno == 1 && fd < 0)
  85         {
  86             sys_setalarm(1000000);
  87             fd = open("/dev/midi", O_RDONLY | O_MIDIFLAG);
  88             if (sys_verbose)
  89                 fprintf(stderr,
  90                     "device 1: tried /dev/midi READONLY; returned %d\n", fd);
  91         }
  92         if (fd < 0)
  93         {
  94             sys_setalarm(1000000);
  95             sprintf(namebuf, "/dev/midi%2.2d", devno);
  96             fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
  97             if (sys_verbose)
  98                 fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
  99                     devno, namebuf, fd);
 100         }
 101         if (fd < 0)
 102         {
 103             sys_setalarm(1000000);
 104             sprintf(namebuf, "/dev/midi%d", devno);
 105             fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
 106             if (sys_verbose)
 107                 fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
 108                     devno, namebuf, fd);
 109         }
 110         if (fd >= 0)
 111             oss_midiinfd[oss_nmidiin++] = fd;
 112         else post("couldn't open MIDI input device %d", devno);
 113     }
 114     for (i = 0, oss_nmidiout = 0; i < nmidiout; i++)
 115     {
 116         int fd = oss_midioutfd[i];
 117         char namebuf[80];
 118         int devno = midioutvec[i];
 119         if (devno == 1 && fd < 0)
 120         {
 121             sys_setalarm(1000000);
 122             fd = open("/dev/midi", O_WRONLY | O_MIDIFLAG);
 123             if (sys_verbose)
 124                 fprintf(stderr,
 125                     "device 1: tried /dev/midi WRITEONLY; returned %d\n", fd);
 126         }
 127         if (fd < 0)
 128         {
 129             sys_setalarm(1000000);
 130             sprintf(namebuf, "/dev/midi%2.2d", devno);
 131             fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
 132             if (sys_verbose)
 133                 fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
 134                     devno, namebuf, fd);
 135         }
 136         if (fd < 0)
 137         {
 138             sys_setalarm(1000000);
 139             sprintf(namebuf, "/dev/midi%d", devno);
 140             fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
 141             if (sys_verbose)
 142                 fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
 143                     devno, namebuf, fd);
 144         }
 145         if (fd >= 0)
 146             oss_midioutfd[oss_nmidiout++] = fd;
 147         else post("couldn't open MIDI output device %d", devno);
 148     }
 149
 150     if (oss_nmidiin < nmidiin || oss_nmidiout < nmidiout || sys_verbose)
 151         post("opened %d MIDI input device(s) and %d MIDI output device(s).",
 152             oss_nmidiin, oss_nmidiout);
 153
 154     sys_setalarm(0);
 155 }
 156
 157 #define md_msglen(x) (((x)<0xC0)?2:((x)<0xE0)?1:((x)<0xF0)?2:\
 158     ((x)==0xF2)?2:((x)<0xF4)?1:0)
 159
 160 void sys_putmidimess(int portno, int a, int b, int c)
 161 {
 162     if (portno >= 0 && portno < oss_nmidiout)
 163     {
 164        switch (md_msglen(a))
 165        {
 166        case 2:
 167             oss_midiout(oss_midioutfd[portno],a);
 168             oss_midiout(oss_midioutfd[portno],b);
 169             oss_midiout(oss_midioutfd[portno],c);
 170             return;
 171        case 1:
 172             oss_midiout(oss_midioutfd[portno],a);
 173             oss_midiout(oss_midioutfd[portno],b);
 174             return;
 175        case 0:
 176             oss_midiout(oss_midioutfd[portno],a);
 177             return;
 178        };
 179     }
 180 }
 181
 182 void sys_putmidibyte(int portno, int byte)
 183 {
 184     if (portno >= 0 && portno < oss_nmidiout)
 185         oss_midiout(oss_midioutfd[portno], byte);
 186 }
 187
 188 #if 0   /* this is the "select" version which doesn't work with OSS
 189         driver for emu10k1 (it doesn't implement select.) */
 190 void sys_poll_midi(void)
 191 {
 192     int i, throttle = 100;
 193     struct timeval timout;
 194     int did = 1, maxfd = 0;
 195     while (did)
 196     {
 197         fd_set readset, writeset, exceptset;
 198         did = 0;
 199         if (throttle-- < 0)
 200             break;
 201         timout.tv_sec = 0;
 202         timout.tv_usec = 0;
 203
 204         FD_ZERO(&writeset);
 205         FD_ZERO(&readset);
 206         FD_ZERO(&exceptset);
 207         for (i = 0; i < oss_nmidiin; i++)
 208         {
 209             if (oss_midiinfd[i] > maxfd)
 210                 maxfd = oss_midiinfd[i];
 211             FD_SET(oss_midiinfd[i], &readset);
 212         }
 213         select(maxfd+1, &readset, &writeset, &exceptset, &timout);
 214         for (i = 0; i < oss_nmidiin; i++)
 215             if (FD_ISSET(oss_midiinfd[i], &readset))
 216         {
 217             char c;
 218             int ret = read(oss_midiinfd[i], &c, 1);
 219             if (ret <= 0)
 220                 fprintf(stderr, "Midi read error\n");
 221             else sys_midibytein(i, (c & 0xff));
 222             did = 1;
 223         }
 224     }
 225 }
 226 #else
 227
 228     /* this version uses the asynchronous "read()" ... */
 229 void sys_poll_midi(void)
 230 {
 231     int i, throttle = 100;
 232     struct timeval timout;
 233     int did = 1, maxfd = 0;
 234     while (did)
 235     {
 236         fd_set readset, writeset, exceptset;
 237         did = 0;
 238         if (throttle-- < 0)
 239             break;
 240         for (i = 0; i < oss_nmidiin; i++)
 241         {
 242             char c;
 243             int ret = read(oss_midiinfd[i], &c, 1);
 244             if (ret < 0)
 245             {
 246                 if (errno != EAGAIN)
 247                     perror("MIDI");
 248             }
 249             else if (ret != 0)
 250             {
 251                 sys_midibytein(i, (c & 0xff));
 252                 did = 1;
 253             }
 254         }
 255     }
 256 }
 257 #endif
 258
 259 void sys_close_midi()
 260 {
 261     int i;
 262     for (i = 0; i < oss_nmidiin; i++)
 263         close(oss_midiinfd[i]);
 264     for (i = 0; i < oss_nmidiout; i++)
 265         close(oss_midioutfd[i]);
 266     oss_nmidiin = oss_nmidiout = 0;
 267 }
 268
 269 #define NSEARCH 10
 270 static int oss_nmidiindevs, oss_nmidioutdevs, oss_initted;
 271
 272 void midi_oss_init(void)
 273 {
 274     int i;
 275     if (oss_initted)
 276         return;
 277     oss_initted = 1;
 278     for (i = 0; i < NSEARCH; i++)
 279     {
 280         int fd;
 281         char namebuf[80];
 282
 283         oss_nmidiindevs = i;
 284             /* try to open the device for reading */
 285         if (i == 0)
 286         {
 287             fd = open("/dev/midi", O_RDONLY | O_NDELAY);
 288             if (fd >= 0)
 289             {
 290                 close(fd);
 291                 continue;
 292             }
 293         }
 294         sprintf(namebuf, "/dev/midi%2.2d", i);
 295         fd = open(namebuf, O_RDONLY | O_NDELAY);
 296         if (fd >= 0)
 297         {
 298             close(fd);
 299             continue;
 300         }
 301         sprintf(namebuf, "/dev/midi%d", i);
 302         fd = open(namebuf, O_RDONLY | O_NDELAY);
 303         if (fd >= 0)
 304         {
 305             close(fd);
 306             continue;
 307         }
 308         break;
 309     }
 310     for (i = 0; i < NSEARCH; i++)
 311     {
 312         int fd;
 313         char namebuf[80];
 314
 315         oss_nmidioutdevs = i;
 316             /* try to open the device for writing */
 317         if (i == 0)
 318         {
 319             fd = open("/dev/midi", O_WRONLY | O_NDELAY);
 320             if (fd >= 0)
 321             {
 322                 close(fd);
 323                 continue;
 324             }
 325         }
 326         sprintf(namebuf, "/dev/midi%2.2d", i);
 327         fd = open(namebuf, O_WRONLY | O_NDELAY);
 328         if (fd >= 0)
 329         {
 330             close(fd);
 331             continue;
 332         }
 333         sprintf(namebuf, "/dev/midi%d", i);
 334         fd = open(namebuf, O_WRONLY | O_NDELAY);
 335         if (fd >= 0)
 336         {
 337             close(fd);
 338             continue;
 339         }
 340         break;
 341     }
 342 }
 343
 344 void midi_getdevs(char *indevlist, int *nindevs,
 345     char *outdevlist, int *noutdevs, int maxndev, int devdescsize)
 346 {
 347     int i, ndev;
 348     if ((ndev = oss_nmidiindevs) > maxndev)
 349         ndev = maxndev;
 350     for (i = 0; i < ndev; i++)
 351         sprintf(indevlist + i * devdescsize, "OSS MIDI device #%d", i+1);
 352     *nindevs = ndev;
 353
 354     if ((ndev = oss_nmidioutdevs) > maxndev)
 355         ndev = maxndev;
 356     for (i = 0; i < ndev; i++)
 357         sprintf(outdevlist + i * devdescsize, "OSS MIDI device #%d", i+1);
 358     *noutdevs = ndev;
 359 }
 360