logo

overlay

My own overlay for experimentations, use with caution, no support is provided git clone https://hacktivis.me/git/overlay.git

portmidi-217-pmsndio.c (9481B)

    

  1. /* pmsndio.c -- PortMidi os-dependent code */
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <sndio.h>
  6. #include <string.h>
  7. #include <poll.h>
  8. #include <errno.h>
  9. #include <pthread.h>
  10. #include "portmidi.h"
  11. #include "pmutil.h"
  12. #include "pminternal.h"
  13. #include "porttime.h"
  15. #define NDEVS 9 
  16. #define SYSEX_MAXLEN 1024 
  18. #define SYSEX_START     0xf0
  19. #define SYSEX_END       0xf7
  21. PmDeviceID pm_default_input_device_id = -1;
  22. PmDeviceID pm_default_output_device_id = -1;
  24. extern pm_fns_node pm_sndio_in_dictionary;
  25. extern pm_fns_node pm_sndio_out_dictionary;
  27. /* length of voice and common messages (status byte included) */
  28. unsigned int voice_len[] = { 3, 3, 3, 3, 2, 2, 3 };
  29. unsigned int common_len[] = { 0, 2, 3, 2, 0, 0, 1, 1 };
  31. struct mio_dev {
  32.     char name[16];
  33.     struct mio_hdl *hdl;
  34.     int mode;
  35.     char errmsg[PM_HOST_ERROR_MSG_LEN];
  36.     pthread_t thread;
  37. } devs[NDEVS];
  39. static void set_mode(struct mio_dev *, unsigned int);
  41. void pm_init()
  42. {
  43.     int i, j, k = 0;
  44.     char devices[][16] = {"midithru", "rmidi", "midi", "snd"};
  46.     /* default */
  47.     strcpy(devs[0].name, MIO_PORTANY);
  48.     pm_add_device("SNDIO", devs[k].name, TRUE, (void *) &devs[k],
  49.         &pm_sndio_in_dictionary);
  50.     pm_add_device("SNDIO", devs[k].name, FALSE, (void *) &devs[k],
  51.         &pm_sndio_out_dictionary);
  52.     k++;
  54.     for (i = 0; i < 4; i++) {
  55.         for (j = 0; j < 2; j++) {
  56.             sprintf(devs[k].name, "%s/%d", devices[i], j);
  57.             pm_add_device("SNDIO", devs[k].name, TRUE, (void *) &devs[k],
  58.               &pm_sndio_in_dictionary);
  59.             pm_add_device("SNDIO", devs[k].name, FALSE, (void *) &devs[k],
  60.               &pm_sndio_out_dictionary);
  61.             k++;
  62.         }
  63.     }
  65.     // this is set when we return to Pm_Initialize, but we need it
  66.     // now in order to (successfully) call Pm_CountDevices()
  67.     pm_initialized = TRUE;
  68.     pm_default_input_device_id = 0;
  69.     pm_default_output_device_id = 1;
  70. }
  72. void pm_term(void)
  73. {
  74.     int i;
  75.     for(i = 0; i < NDEVS; i++) {
  76.         if (devs[i].mode != 0) {
  77.             set_mode(&devs[i], 0);
  78.             if (devs[i].thread) {
  79.                 pthread_join(devs[i].thread, NULL);
  80.                 devs[i].thread = NULL;
  81.             }
  82.         }
  83.     }
  84. }
  86. PmDeviceID Pm_GetDefaultInputDeviceID() {
  87.     Pm_Initialize();
  88.     return pm_default_input_device_id; 
  89. }
  91. PmDeviceID Pm_GetDefaultOutputDeviceID() {
  92.     Pm_Initialize();
  93.     return pm_default_output_device_id;
  94. }
  96. void *pm_alloc(size_t s) { return malloc(s); }
  98. void pm_free(void *ptr) { free(ptr); }
  100. /* midi_message_length -- how many bytes in a message? */
  101. static int midi_message_length(PmMessage message)
  102. {
  103.     unsigned char st = message & 0xff;
  104.     if (st >= 0xf8)
  105. 	return 1;
  106.     else if (st >= 0xf0)
  107.         return common_len[st & 7];
  108.     else if (st >= 0x80)
  109.         return voice_len[(st >> 4) & 7];
  110.     else 
  111.         return 0;
  112. }
  114. void* input_thread(void *param)
  115. {
  116.     PmInternal *midi = (PmInternal*)param;
  117.     struct mio_dev *dev = (struct mio_dev *) midi->descriptor;
  118.     struct pollfd pfd[1];
  119.     nfds_t nfds;
  120.     unsigned char st = 0, c = 0;
  121.     int rc, revents, idx = 0, len = 0;
  122.     size_t todo = 0;
  123.     unsigned char buf[0x200], *p;
  124.     PmEvent pm_ev, pm_ev_rt;
  125.     unsigned char sysex_data[SYSEX_MAXLEN];
  127.     while(dev->mode & MIO_IN) {
  128.         if (todo == 0) {
  129.             nfds = mio_pollfd(dev->hdl, pfd, POLLIN);
  130.             rc = poll(pfd, nfds, 100);
  131.             if (rc < 0) {
  132.                 if (errno == EINTR)
  133.                     continue;
  134.                 break;
  135.             }
  136.             revents = mio_revents(dev->hdl, pfd);
  137.             if (!(revents & POLLIN))
  138.                 continue;
  140.             todo = mio_read(dev->hdl, buf, sizeof(buf));
  141.             if (todo == 0)
  142.                 continue;
  143.             p = buf;
  144.         }
  145.         c = *p++;
  146.         todo--;
  148.         if (c >= 0xf8) {
  149.             pm_ev_rt.message = c;
  150.             pm_ev_rt.timestamp = Pt_Time();
  151.             pm_read_short(midi, &pm_ev_rt);
  152.         } else if (c == SYSEX_END) {
  153.             if (st == SYSEX_START) {
  154.                 sysex_data[idx++] = c;
  155.                 pm_read_bytes(midi, sysex_data, idx, Pt_Time());
  156.             }
  157.             st = 0;
  158.             idx = 0;
  159.         } else if (c == SYSEX_START) {
  160.             st = c;
  161.             idx = 0;
  162.             sysex_data[idx++] = c;
  163.         } else if (c >= 0xf0) {
  164.             pm_ev.message = c;
  165.             len = common_len[c & 7];
  166.             st = c;
  167.             idx = 1;
  168.         } else if (c >= 0x80) {
  169.             pm_ev.message = c;
  170.             len = voice_len[(c >> 4) & 7];
  171.             st = c;
  172.             idx = 1;
  173.         } else if (st == SYSEX_START) {
  174.             if (idx == SYSEX_MAXLEN) {
  175.                 fprintf(stderr, "the message is too long\n");
  176.                 idx = st = 0;
  177.             } else {
  178.                 sysex_data[idx++] = c;
  179.             }
  180.         } else if (st) {
  181.             if (idx == 0 && st != SYSEX_START)
  182.                 pm_ev.message |= (c << (8 * idx++));
  183.             pm_ev.message |= (c << (8 * idx++));
  184.             if (idx == len) {
  185.                 pm_read_short(midi, &pm_ev);
  186.                 if (st >= 0xf0)
  187.                     st = 0;
  188.                 idx = 0;
  189.             }
  190.         }
  191.     }
  193.     pthread_exit(NULL);
  194.     return NULL;
  195. }
  197. static void set_mode(struct mio_dev *dev, unsigned int mode) {
  198.     if (dev->mode != 0)
  199.         mio_close(dev->hdl);
  200.     dev->mode = 0;
  201.     if (mode != 0)
  202.         dev->hdl = mio_open(dev->name, mode, 0);
  203.     if (dev->hdl)
  204.         dev->mode = mode;
  205. }
  207. static PmError sndio_out_open(PmInternal *midi, void *driverInfo)
  208. {
  209.     descriptor_type desc = &descriptors[midi->device_id];
  210.     struct mio_dev *dev = (struct mio_dev *) desc->descriptor;
  212.     if (dev->mode & MIO_OUT)
  213.         return pmNoError;
  215.     set_mode(dev, dev->mode | MIO_OUT);
  216.     if (!(dev->mode & MIO_OUT)) {
  217.         snprintf(dev->errmsg, PM_HOST_ERROR_MSG_LEN,
  218.           "mio_open (output) failed: %s\n", dev->name);
  219.         return pmHostError;
  220.     }
  222.     midi->descriptor = (void *)dev;
  223.     return pmNoError;
  224. }
  226. static PmError sndio_in_open(PmInternal *midi, void *driverInfo)
  227. {
  228.     descriptor_type desc = &descriptors[midi->device_id];
  229.     struct mio_dev *dev = (struct mio_dev *) desc->descriptor;
  231.     if (dev->mode & MIO_IN)
  232.         return pmNoError;
  234.     set_mode(dev, dev->mode | MIO_IN);
  235.     if (!(dev->mode & MIO_IN)) {
  236.         snprintf(dev->errmsg, PM_HOST_ERROR_MSG_LEN,
  237.           "mio_open (input) failed: %s\n", dev->name);
  238.         return pmHostError;
  239.     }
  240.     midi->descriptor = (void *)dev;
  241.     pthread_attr_t attr;
  242.     pthread_attr_init(&attr);
  243.     pthread_create(&dev->thread, &attr, input_thread, ( void* )midi);
  244.     return pmNoError;
  245. }
  247. static PmError sndio_out_close(PmInternal *midi)
  248. {
  249.     struct mio_dev *dev = (struct mio_dev *) midi->descriptor;
  251.     if (dev->mode & MIO_OUT)
  252.         set_mode(dev, dev->mode & ~MIO_OUT);
  253.     return pmNoError;
  254. }
  256. static PmError sndio_in_close(PmInternal *midi)
  257. {
  258.     struct mio_dev *dev = (struct mio_dev *) midi->descriptor;
  260.     if (dev->mode & MIO_IN) {
  261.         set_mode(dev, dev->mode & ~MIO_IN);
  262.         pthread_join(dev->thread, NULL);
  263.         dev->thread = NULL;
  264.     }
  265.     return pmNoError;
  266. }
  268. static PmError sndio_abort(PmInternal *midi)
  269. {
  270.     return pmNoError;
  271. }
  273. static PmTimestamp sndio_synchronize(PmInternal *midi)
  274. {
  275.     return 0;
  276. }
  278. static PmError do_write(struct mio_dev *dev, const void *addr, size_t nbytes)
  279. {
  280.     size_t w = mio_write(dev->hdl, addr, nbytes);
  282.     if (w != nbytes) {
  283.         snprintf(dev->errmsg, PM_HOST_ERROR_MSG_LEN, 
  284.           "mio_write failed, bytes written:%zu\n", w);
  285.         return pmHostError;
  286.     }
  287.     return pmNoError;
  288. }
  290. static PmError sndio_write_byte(PmInternal *midi, unsigned char byte,
  291.                         PmTimestamp timestamp)
  292. {
  293.     struct mio_dev *dev = (struct mio_dev *) midi->descriptor;
  295.     return do_write(dev, &byte, 1);
  296. }
  298. static PmError sndio_write_short(PmInternal *midi, PmEvent *event)
  299. {
  300.     struct mio_dev *dev = (struct mio_dev *) midi->descriptor;
  301.     int nbytes = midi_message_length(event->message);
  303.     if (midi->latency > 0) {
  304.         /* XXX the event should be queued for later playback */
  305.         return do_write(dev, &event->message, nbytes);
  306.     } else {
  307.         return do_write(dev, &event->message, nbytes);
  308.     }
  309.     return pmNoError;
  310. }
  312. static PmError sndio_write_flush(PmInternal *midi, PmTimestamp timestamp)
  313. {
  314.     return pmNoError;
  315. }
  317. PmError sndio_sysex(PmInternal *midi, PmTimestamp timestamp)
  318. {
  319.     return pmNoError;
  320. }
  322. static unsigned int sndio_has_host_error(PmInternal *midi)
  323. {
  324.     struct mio_dev *dev = (struct mio_dev *) midi->descriptor;
  326.     return (dev->errmsg[0] != '\0');
  327. }
  329. static void sndio_get_host_error(PmInternal *midi, char *msg, unsigned int len)
  330. {
  331.     struct mio_dev *dev = (struct mio_dev *) midi->descriptor;
  333.     strlcpy(msg, dev->errmsg, len);
  334.     dev->errmsg[0] = '\0';
  335. }
  337. pm_fns_node pm_sndio_in_dictionary = {
  338.     none_write_short,
  339.     none_sysex,
  340.     none_sysex,
  341.     none_write_byte,
  342.     none_write_short,
  343.     none_write_flush,
  344.     sndio_synchronize,
  345.     sndio_in_open,
  346.     sndio_abort,
  347.     sndio_in_close,
  348.     success_poll,
  349.     sndio_has_host_error,
  350.     sndio_get_host_error
  351. };
  353. pm_fns_node pm_sndio_out_dictionary = {
  354.     sndio_write_short,
  355.     sndio_sysex,
  356.     sndio_sysex,
  357.     sndio_write_byte,
  358.     sndio_write_short,
  359.     sndio_write_flush,
  360.     sndio_synchronize,
  361.     sndio_out_open,
  362.     sndio_abort,
  363.     sndio_out_close,
  364.     none_poll,
  365.     sndio_has_host_error,
  366.     sndio_get_host_error
  367. };