开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
fluid_oss.c
资源名称：trunk-r284.zip　[点击查看]
上传用户：tjmskj2
上传日期：2020-08-17
资源大小：577k
文件大小：17k
源码类别：

midi

开发平台：

C/C++

fluid_oss.c：源码内容
  1. /* FluidSynth - A Software Synthesizer
  2.  *
  3.  * Copyright (C) 2003  Peter Hanappe and others.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Library General Public License
  7.  * as published by the Free Software Foundation; either version 2 of
  8.  * the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Library General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Library General Public
  16.  * License along with this library; if not, write to the Free
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.  * 02111-1307, USA
  19.  */
  22. /* fluid_oss.c
  23.  *
  24.  * Drivers for the Open (?) Sound System
  25.  */
  27. #include "fluid_synth.h"
  28. #include "fluid_midi.h"
  29. #include "fluid_adriver.h"
  30. #include "fluid_mdriver.h"
  31. #include "fluid_settings.h"
  33. #if OSS_SUPPORT
  35. #include <sys/soundcard.h>
  36. #include <sys/ioctl.h>
  37. #include <sys/time.h>
  38. #include <sys/types.h>
  39. #include <sys/stat.h>
  40. #include <fcntl.h>
  41. #include <unistd.h>
  42. #include <errno.h>
  43. #include <sys/poll.h>
  45. #define BUFFER_LENGTH 512
  48. /** fluid_oss_audio_driver_t
  49.  *
  50.  * This structure should not be accessed directly. Use audio port
  51.  * functions instead.
  52.  */
  53. typedef struct {
  54.   fluid_audio_driver_t driver;
  55.   fluid_synth_t* synth;
  56.   fluid_audio_callback_t read;
  57.   void* buffer;
  58.   fluid_thread_t *thread;
  59.   int cont;
  60.   int dspfd;
  61.   int buffer_size;
  62.   int buffer_byte_size;
  63.   int bigendian;
  64.   int formats;
  65.   int format;
  66.   int caps;
  67.   fluid_audio_func_t callback;
  68.   void* data;
  69.   float* buffers[2];
  70. } fluid_oss_audio_driver_t;
  72. int delete_fluid_oss_audio_driver(fluid_audio_driver_t* p);
  74. /* local utilities */
  75. static int fluid_oss_set_queue_size(fluid_oss_audio_driver_t* dev, int ss, int ch, int qs, int bs);
  76. static void fluid_oss_audio_run(void* d);
  77. static void fluid_oss_audio_run2(void* d);
  80. typedef struct {
  81.   fluid_midi_driver_t driver;
  82.   int fd;
  83.   fluid_thread_t *thread;
  84.   int status;
  85.   unsigned char buffer[BUFFER_LENGTH];
  86.   fluid_midi_parser_t* parser;
  87. } fluid_oss_midi_driver_t;
  89. fluid_midi_driver_t*
  90. new_fluid_oss_midi_driver(fluid_settings_t* settings,
  91.  handle_midi_event_func_t handler, void* data);
  92. int delete_fluid_oss_midi_driver(fluid_midi_driver_t* p);
  93. int fluid_oss_midi_driver_status(fluid_midi_driver_t* p);
  94. static void fluid_oss_midi_run(void* d);
  97. void
  98. fluid_oss_audio_driver_settings(fluid_settings_t* settings)
  99. {
  100.   fluid_settings_register_str(settings, "audio.oss.device", "/dev/dsp", 0, NULL, NULL);
  101. }
  103. /*
  104.  * new_fluid_oss_audio_driver
  105.  */
  106. fluid_audio_driver_t*
  107. new_fluid_oss_audio_driver(fluid_settings_t* settings, fluid_synth_t* synth)
  108. {
  109.   fluid_oss_audio_driver_t* dev = NULL;
  110.   int channels, sr, sample_size = 0, oss_format;
  111.   struct stat devstat;
  112.   int queuesize;
  113.   double sample_rate;
  114.   int periods, period_size;
  115.   int realtime_prio = 0;
  116.   char* devname = NULL;
  117.   int format;
  119.   dev = FLUID_NEW(fluid_oss_audio_driver_t);
  120.   if (dev == NULL) {
  121.     FLUID_LOG(FLUID_ERR, "Out of memory");
  122.     return NULL;
  123.   }
  124.   FLUID_MEMSET(dev, 0, sizeof(fluid_oss_audio_driver_t));
  126.   fluid_settings_getint(settings, "audio.periods", &periods);
  127.   fluid_settings_getint(settings, "audio.period-size", &period_size);
  128.   fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
  129.   fluid_settings_getint (settings, "audio.realtime-prio", &realtime_prio);
  131.   dev->dspfd = -1;
  132.   dev->synth = synth;
  133.   dev->callback = NULL;
  134.   dev->data = NULL;
  135.   dev->cont = 1;
  136.   dev->buffer_size = (int) period_size;
  137.   queuesize = (int) (periods * period_size);
  139.   if (fluid_settings_str_equal(settings, "audio.sample-format", "16bits")) {
  140.     sample_size = 16;
  141.     oss_format = AFMT_S16_LE;
  142.     dev->read = fluid_synth_write_s16;
  143.     dev->buffer_byte_size = dev->buffer_size * 4;
  145.   } else if (fluid_settings_str_equal(settings, "audio.sample-format", "float")) {
  146.     sample_size = 32;
  147.     oss_format = -1;
  148.     dev->read = fluid_synth_write_float;
  149.     dev->buffer_byte_size = dev->buffer_size * 8;
  151.   } else {
  152.     FLUID_LOG(FLUID_ERR, "Unknown sample format");
  153.     goto error_recovery;
  154.   }
  156.   dev->buffer = FLUID_MALLOC(dev->buffer_byte_size);
  157.   if (dev->buffer == NULL) {
  158.     FLUID_LOG(FLUID_ERR, "Out of memory");
  159.     goto error_recovery;
  160.   }
  162.   if (!fluid_settings_dupstr(settings, "audio.oss.device", &devname) || !devname) {         /* ++ alloc device name */
  163.     devname = FLUID_STRDUP ("/dev/dsp");
  165.     if (devname == NULL) {
  166.       FLUID_LOG(FLUID_ERR, "Out of memory");
  167.       goto error_recovery;
  168.     }
  169.   }
  171.   if (stat(devname, &devstat) == -1) {
  172.     FLUID_LOG(FLUID_ERR, "Device <%s> does not exists", devname);
  173.     goto error_recovery;
  174.   }
  175.   if ((devstat.st_mode & S_IFCHR) != S_IFCHR) {
  176.     FLUID_LOG(FLUID_ERR, "Device <%s> is not a device file", devname);
  177.     goto error_recovery;
  178.   }
  180.   dev->dspfd = open(devname, O_WRONLY, 0);
  182.   if (dev->dspfd == -1) {
  183.     FLUID_LOG(FLUID_ERR, "Device <%s> could not be opened for writing: %s",
  184.      devname, strerror(errno));
  185.     goto error_recovery;
  186.   }
  188.   if (fluid_oss_set_queue_size(dev, sample_size, 2, queuesize, period_size) < 0) {
  189.     FLUID_LOG(FLUID_ERR, "Can't set device buffer size");
  190.     goto error_recovery;
  191.   }
  193.   format = oss_format;
  194.   if (ioctl(dev->dspfd, SNDCTL_DSP_SETFMT, &oss_format) < 0) {
  195.     FLUID_LOG(FLUID_ERR, "Can't set the sample format");
  196.     goto error_recovery;
  197.   }
  198.   if (oss_format != format) {
  199.     FLUID_LOG(FLUID_ERR, "Can't set the sample format");
  200.     goto error_recovery;
  201.   }
  203.   channels = 2;
  204.   if (ioctl(dev->dspfd, SOUND_PCM_WRITE_CHANNELS, &channels) < 0){
  205.     FLUID_LOG(FLUID_ERR, "Can't set the number of channels");
  206.     goto error_recovery;
  207.   }
  208.   if (channels != 2) {
  209.     FLUID_LOG(FLUID_ERR, "Can't set the number of channels");
  210.     goto error_recovery;
  211.   }
  213.   sr = sample_rate;
  214.   if (ioctl(dev->dspfd, SNDCTL_DSP_SPEED, &sr) < 0){
  215.     FLUID_LOG(FLUID_ERR, "Can't set the sample rate");
  216.     goto error_recovery;
  217.   }
  218.   if ((sr < 0.95 * sample_rate) ||
  219.       (sr > 1.05 * sample_rate)) {
  220.     FLUID_LOG(FLUID_ERR, "Can't set the sample rate");
  221.     goto error_recovery;
  222.   }
  224.   /* Create the audio thread */
  225.   dev->thread = new_fluid_thread (fluid_oss_audio_run, dev, realtime_prio, FALSE);
  227.   if (!dev->thread)
  228.     goto error_recovery;
  230.   if (devname) FLUID_FREE (devname);    /* -- free device name */
  232.   return (fluid_audio_driver_t*) dev;
  234. error_recovery:
  235.   if (devname) FLUID_FREE (devname);    /* -- free device name */
  236.   delete_fluid_oss_audio_driver((fluid_audio_driver_t*) dev);
  237.   return NULL;
  238. }
  240. fluid_audio_driver_t*
  241. new_fluid_oss_audio_driver2(fluid_settings_t* settings, fluid_audio_func_t func, void* data)
  242. {
  243.   fluid_oss_audio_driver_t* dev = NULL;
  244.   int channels, sr;
  245.   struct stat devstat;
  246.   int queuesize;
  247.   double sample_rate;
  248.   int periods, period_size;
  249.   char* devname = NULL;
  250.   int realtime_prio = 0;
  251.   int format;
  253.   dev = FLUID_NEW(fluid_oss_audio_driver_t);
  254.   if (dev == NULL) {
  255.     FLUID_LOG(FLUID_ERR, "Out of memory");
  256.     return NULL;
  257.   }
  258.   FLUID_MEMSET(dev, 0, sizeof(fluid_oss_audio_driver_t));
  260.   fluid_settings_getint(settings, "audio.periods", &periods);
  261.   fluid_settings_getint(settings, "audio.period-size", &period_size);
  262.   fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
  263.   fluid_settings_getint (settings, "audio.realtime-prio", &realtime_prio);
  265.   dev->dspfd = -1;
  266.   dev->synth = NULL;
  267.   dev->read = NULL;
  268.   dev->callback = func;
  269.   dev->data = data;
  270.   dev->cont = 1;
  271.   dev->buffer_size = (int) period_size;
  272.   queuesize = (int) (periods * period_size);
  273.   dev->buffer_byte_size = dev->buffer_size * 2 * 2; /* 2 channels * 16 bits audio */
  276.   if (!fluid_settings_dupstr(settings, "audio.oss.device", &devname) || !devname) {
  277.     devname = FLUID_STRDUP ("/dev/dsp");
  279.     if (!devname)
  280.     {
  281.       FLUID_LOG(FLUID_ERR, "Out of memory");
  282.       goto error_recovery;
  283.     }
  284.   }
  286.   if (stat(devname, &devstat) == -1) {
  287.     FLUID_LOG(FLUID_ERR, "Device <%s> does not exists", devname);
  288.     goto error_recovery;
  289.   }
  290.   if ((devstat.st_mode & S_IFCHR) != S_IFCHR) {
  291.     FLUID_LOG(FLUID_ERR, "Device <%s> is not a device file", devname);
  292.     goto error_recovery;
  293.   }
  295.   dev->dspfd = open(devname, O_WRONLY, 0);
  296.   if (dev->dspfd == -1) {
  297.     FLUID_LOG(FLUID_ERR, "Device <%s> could not be opened for writing: %s",
  298.      devname, strerror(errno));
  299.     goto error_recovery;
  300.   }
  303.   if (fluid_oss_set_queue_size(dev, 16, 2, queuesize, period_size) < 0) {
  304.     FLUID_LOG(FLUID_ERR, "Can't set device buffer size");
  305.     goto error_recovery;
  306.   }
  308.   format = AFMT_S16_LE;
  309.   if (ioctl(dev->dspfd, SNDCTL_DSP_SETFMT, &format) < 0) {
  310.     FLUID_LOG(FLUID_ERR, "Can't set the sample format");
  311.     goto error_recovery;
  312.   }
  313.   if (format != AFMT_S16_LE) {
  314.     FLUID_LOG(FLUID_ERR, "Can't set the sample format");
  315.     goto error_recovery;
  316.   }
  318.   channels = 2;
  319.   if (ioctl(dev->dspfd, SOUND_PCM_WRITE_CHANNELS, &channels) < 0){
  320.     FLUID_LOG(FLUID_ERR, "Can't set the number of channels");
  321.     goto error_recovery;
  322.   }
  323.   if (channels != 2) {
  324.     FLUID_LOG(FLUID_ERR, "Can't set the number of channels");
  325.     goto error_recovery;
  326.   }
  328.   sr = sample_rate;
  329.   if (ioctl(dev->dspfd, SNDCTL_DSP_SPEED, &sr) < 0){
  330.     FLUID_LOG(FLUID_ERR, "Can't set the sample rate");
  331.     goto error_recovery;
  332.   }
  333.   if ((sr < 0.95 * sample_rate) ||
  334.       (sr > 1.05 * sample_rate)) {
  335.     FLUID_LOG(FLUID_ERR, "Can't set the sample rate");
  336.     goto error_recovery;
  337.   }
  339.   /* allocate the buffers. FIXME!!! don't use interleaved samples */
  340.   dev->buffer = FLUID_MALLOC(dev->buffer_byte_size);
  341.   dev->buffers[0] = FLUID_ARRAY(float, dev->buffer_size);
  342.   dev->buffers[1] = FLUID_ARRAY(float, dev->buffer_size);
  343.   if ((dev->buffer == NULL) || (dev->buffers[0] == NULL) || (dev->buffers[1] == NULL)) {
  344.     FLUID_LOG(FLUID_ERR, "Out of memory");
  345.     goto error_recovery;
  346.   }
  348.   /* Create the audio thread */
  349.   dev->thread = new_fluid_thread (fluid_oss_audio_run2, dev, realtime_prio, FALSE);
  351.   if (!dev->thread)
  352.     goto error_recovery;
  354.   if (devname) FLUID_FREE (devname);    /* -- free device name */
  356.   return (fluid_audio_driver_t*) dev;
  358. error_recovery:
  359.   if (devname) FLUID_FREE (devname);    /* -- free device name */
  360.   delete_fluid_oss_audio_driver((fluid_audio_driver_t*) dev);
  361.   return NULL;
  362. }
  364. /*
  365.  * delete_fluid_oss_audio_driver
  366.  */
  367. int
  368. delete_fluid_oss_audio_driver(fluid_audio_driver_t* p)
  369. {
  370.   fluid_oss_audio_driver_t* dev = (fluid_oss_audio_driver_t*) p;
  372.   if (dev == NULL) {
  373.     return FLUID_OK;
  374.   }
  376.   dev->cont = 0;
  378.   if (dev->thread)
  379.     fluid_thread_join (dev->thread);
  381.   if (dev->dspfd >= 0) {
  382.     close(dev->dspfd);
  383.   }
  384.   if (dev->buffer != NULL) {
  385.     FLUID_FREE(dev->buffer);
  386.   }
  387.   FLUID_FREE(dev);
  388.   return FLUID_OK;
  389. }
  391. /**
  392.  *  fluid_oss_set_queue_size
  393.  *
  394.  *  Set the internal buffersize of the output device.
  395.  *
  396.  *  @param ss Sample size in bits
  397.  *  @param ch Number of channels
  398.  *  @param qs The queue size in frames
  399.  *  @param bs The synthesis buffer size in frames
  400.  */
  401. int
  402. fluid_oss_set_queue_size(fluid_oss_audio_driver_t* dev, int ss, int ch, int qs, int bs)
  403. {
  404.   unsigned int fragmentSize;
  405.   unsigned int fragSizePower;
  406.   unsigned int fragments;
  407.   unsigned int fragmentsPower;
  409.   fragmentSize = (unsigned int) (bs * ch * ss / 8);
  411.   fragSizePower = 0;
  412.   while (0 < fragmentSize) {
  413.     fragmentSize = (fragmentSize >> 1);
  414.     fragSizePower++;
  415.   }
  416.   fragSizePower--;
  418.   fragments = (unsigned int) (qs / bs);
  419.   if (fragments < 2) {
  420.     fragments = 2;
  421.   }
  423.   /* make sure fragments is a power of 2 */
  424.   fragmentsPower = 0;
  425.   while (0 < fragments) {
  426.     fragments = (fragments >> 1);
  427.     fragmentsPower++;
  428.   }
  429.   fragmentsPower--;
  431.   fragments = (1 << fragmentsPower);
  432.   fragments = (fragments << 16) + fragSizePower;
  434.   return ioctl(dev->dspfd, SNDCTL_DSP_SETFRAGMENT, &fragments);
  435. }
  437. /*
  438.  * fluid_oss_audio_run
  439.  */
  440. void
  441. fluid_oss_audio_run(void* d)
  442. {
  443.   fluid_oss_audio_driver_t* dev = (fluid_oss_audio_driver_t*) d;
  444.   fluid_synth_t* synth = dev->synth;
  445.   void* buffer = dev->buffer;
  446.   int len = dev->buffer_size;
  448.   /* it's as simple as that: */
  449.   while (dev->cont)
  450.   {
  451.     dev->read (synth, len, buffer, 0, 2, buffer, 1, 2);
  453.     if (write (dev->dspfd, buffer, dev->buffer_byte_size) < 0)
  454.     {
  455.       FLUID_LOG(FLUID_ERR, "Error writing to OSS sound device: %s",
  456.                 g_strerror (errno));
  457.       break;
  458.     }
  459.   }
  461.   FLUID_LOG(FLUID_DBG, "Audio thread finished");
  462. }
  465. /*
  466.  * fluid_oss_audio_run
  467.  */
  468. void
  469. fluid_oss_audio_run2(void* d)
  470. {
  471.   fluid_oss_audio_driver_t* dev = (fluid_oss_audio_driver_t*) d;
  472.   short* buffer = (short*) dev->buffer;
  473.   float* left = dev->buffers[0];
  474.   float* right = dev->buffers[1];
  475.   int buffer_size = dev->buffer_size;
  476.   int dither_index = 0;
  478.   FLUID_LOG(FLUID_DBG, "Audio thread running");
  480.   /* it's as simple as that: */
  481.   while (dev->cont)
  482.   {
  483.     (*dev->callback)(dev->data, buffer_size, 0, NULL, 2, dev->buffers);
  485.     fluid_synth_dither_s16 (&dither_index, buffer_size, left, right,
  486.     buffer, 0, 2, buffer, 1, 2);
  488.     if (write (dev->dspfd, buffer, dev->buffer_byte_size) < 0)
  489.     {
  490.       FLUID_LOG(FLUID_ERR, "Error writing to OSS sound device: %s",
  491.                 g_strerror (errno));
  492.       break;
  493.     }
  494.   }
  496.   FLUID_LOG(FLUID_DBG, "Audio thread finished");
  497. }
  500. void fluid_oss_midi_driver_settings(fluid_settings_t* settings)
  501. {
  502.   fluid_settings_register_str(settings, "midi.oss.device", "/dev/midi", 0, NULL, NULL);
  503. }
  505. /*
  506.  * new_fluid_oss_midi_driver
  507.  */
  508. fluid_midi_driver_t*
  509. new_fluid_oss_midi_driver(fluid_settings_t* settings,
  510.  handle_midi_event_func_t handler, void* data)
  511. {
  512.   fluid_oss_midi_driver_t* dev;
  513.   int realtime_prio = 0;
  514.   char* device = NULL;
  516.   /* not much use doing anything */
  517.   if (handler == NULL) {
  518.     FLUID_LOG(FLUID_ERR, "Invalid argument");
  519.     return NULL;
  520.   }
  522.   /* allocate the device */
  523.   dev = FLUID_NEW(fluid_oss_midi_driver_t);
  524.   if (dev == NULL) {
  525.     FLUID_LOG(FLUID_ERR, "Out of memory");
  526.     return NULL;
  527.   }
  528.   FLUID_MEMSET(dev, 0, sizeof(fluid_oss_midi_driver_t));
  529.   dev->fd = -1;
  531.   dev->driver.handler = handler;
  532.   dev->driver.data = data;
  534.   /* allocate one event to store the input data */
  535.   dev->parser = new_fluid_midi_parser();
  536.   if (dev->parser == NULL) {
  537.     FLUID_LOG(FLUID_ERR, "Out of memory");
  538.     goto error_recovery;
  539.   }
  541.   /* get the device name. if none is specified, use the default device. */
  542.   fluid_settings_dupstr(settings, "midi.oss.device", &device);  /* ++ alloc device name */
  544.   if (device == NULL) {
  545.     device = FLUID_STRDUP ("/dev/midi");
  547.     if (!device)
  548.     {
  549.       FLUID_LOG(FLUID_ERR, "Out of memory");
  550.       goto error_recovery;
  551.     }
  552.   }
  554.   fluid_settings_getint (settings, "midi.realtime-prio", &realtime_prio);
  556.   /* open the default hardware device. only use midi in. */
  557.   dev->fd = open(device, O_RDONLY, 0);
  558.   if (dev->fd < 0) {
  559.     perror(device);
  560.     goto error_recovery;
  561.   }
  563.   if (fcntl (dev->fd, F_SETFL, O_NONBLOCK) == -1)
  564.   {
  565.     FLUID_LOG(FLUID_ERR, "Failed to set OSS MIDI device to non-blocking: %s",
  566.               strerror (errno));
  567.     goto error_recovery;
  568.   }
  570.   dev->status = FLUID_MIDI_READY;
  572.   /* create MIDI thread */
  573.   dev->thread = new_fluid_thread (fluid_oss_midi_run, dev, realtime_prio, FALSE);
  575.   if (!dev->thread)
  576.     goto error_recovery;
  578.   if (device) FLUID_FREE (device);      /* ++ free device */
  580.   return (fluid_midi_driver_t*) dev;
  582.  error_recovery:
  583.   if (device) FLUID_FREE (device);      /* ++ free device */
  584.   delete_fluid_oss_midi_driver((fluid_midi_driver_t*) dev);
  585.   return NULL;
  586. }
  588. /*
  589.  * delete_fluid_oss_midi_driver
  590.  */
  591. int
  592. delete_fluid_oss_midi_driver(fluid_midi_driver_t* p)
  593. {
  594.   fluid_oss_midi_driver_t* dev;
  596.   dev = (fluid_oss_midi_driver_t*) p;
  597.   if (dev == NULL) {
  598.     return FLUID_OK;
  599.   }
  601.   /* cancel the thread and wait for it before cleaning up */
  602.   dev->status = FLUID_MIDI_DONE;
  604.   if (dev->thread)
  605.     fluid_thread_join (dev->thread);
  607.   if (dev->fd >= 0) {
  608.     close(dev->fd);
  609.   }
  610.   if (dev->parser != NULL) {
  611.     delete_fluid_midi_parser(dev->parser);
  612.   }
  613.   FLUID_FREE(dev);
  614.   return FLUID_OK;
  615. }
  617. /*
  618.  * fluid_oss_midi_run
  619.  */
  620. void
  621. fluid_oss_midi_run(void* d)
  622. {
  623.   fluid_oss_midi_driver_t* dev = (fluid_oss_midi_driver_t*) d;
  624.   fluid_midi_event_t* evt;
  625.   struct pollfd fds;
  626.   int n, i;
  628.   /* go into a loop until someone tells us to stop */
  629.   dev->status = FLUID_MIDI_LISTENING;
  631.   fds.fd = dev->fd;
  632.   fds.events = POLLIN;
  633.   fds.revents = 0;
  635.   while (dev->status == FLUID_MIDI_LISTENING) {
  637.     n = poll (&fds, 1, 100);
  639.     if (n == 0) continue;
  641.     if (n < 0)
  642.     {
  643.       FLUID_LOG(FLUID_ERR, "Error waiting for MIDI input: %s", strerror (errno));
  644.       break;
  645.     }
  647.     /* read new data */
  648.     n = read(dev->fd, dev->buffer, BUFFER_LENGTH);
  650.     if (n == -EAGAIN) continue;
  652.     if (n < 0) {
  653.       perror("read");
  654.       FLUID_LOG(FLUID_ERR, "Failed to read the midi input");
  655.       break;
  656.     }
  658.     /* let the parser convert the data into events */
  659.     for (i = 0; i < n; i++) {
  660.       evt = fluid_midi_parser_parse(dev->parser, dev->buffer[i]);
  661.       if (evt != NULL) {
  662. /* send the event to the next link in the chain */
  663. (*dev->driver.handler)(dev->driver.data, evt);
  664.       }
  665.     }
  666.   }
  667. }
  669. int
  670. fluid_oss_midi_driver_status(fluid_midi_driver_t* p)
  671. {
  672.   fluid_oss_midi_driver_t* dev = (fluid_oss_midi_driver_t*) p;
  673.   return dev->status;
  674. }
  676. #endif /*#if OSS_SUPPORT */