Index: ext/midi/midi_parser.c
===================================================================
--- ext/midi/midi_parser.c	(revision b60dd4ae028d987b1e9bdbd6b71e62f529465109)
+++ ext/midi/midi_parser.c	(revision b60dd4ae028d987b1e9bdbd6b71e62f529465109)
@@ -0,0 +1,221 @@
+/* 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License
+ * as published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *  
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307, USA
+ */
+
+/* This file orginally taken from, Fluidsynth, Peter Hanappe */
+
+#include "aubio_priv.h"
+#include "midi.h"
+#include "midi_event.h"
+#include "midi_parser.h"
+
+/** aubio_midi_parser_t */
+struct _aubio_midi_parser_t {
+  unsigned char status;       /**< Identifies the type of event, that is 
+                                 currently received ('Noteon', 'Pitch Bend'
+                                 etc). */
+  unsigned char channel;      /**< The channel of the event that is received 
+                                (in case of a channel event) */
+  unsigned int nr_bytes;      /**< How many bytes have been read for the 
+                                 current event? */
+  unsigned int nr_bytes_total;/**< How many bytes does the current event 
+                                type include? */
+  unsigned short p[AUBIO_MIDI_PARSER_MAX_PAR]; /**< The parameters */
+
+  aubio_midi_event_t event;   /**< The event, that is returned to the 
+                                 MIDI driver. */
+};
+
+/** new_aubio_midi_parser */
+aubio_midi_parser_t* new_aubio_midi_parser()
+{
+  aubio_midi_parser_t* parser;
+  parser = AUBIO_NEW(aubio_midi_parser_t);
+  if (parser == NULL) {
+    AUBIO_ERR("Out of memory");
+    return NULL;
+  }
+  /* As long as the status is 0, the parser won't do anything -> no need to
+   * initialize all the fields. */
+  parser->status = 0; 
+  return parser;
+}
+
+/** del_aubio_midi_parser */
+int del_aubio_midi_parser(aubio_midi_parser_t* parser)
+{
+  AUBIO_FREE(parser);
+  return AUBIO_OK;
+}
+
+/** aubio_midi_parser_parse
+ *
+ * The MIDI byte stream is fed into the parser, one byte at a time.
+ * As soon as the parser has recognized an event, it will return it.
+ * Otherwise it returns NULL.
+ */
+aubio_midi_event_t* aubio_midi_parser_parse(aubio_midi_parser_t* parser, 
+    unsigned char c)
+{
+  /*********************************************************************/
+  /* 'Process' system real-time messages                               */
+  /*********************************************************************/
+  /* There are not too many real-time messages that are of interest here.
+   * They can occur anywhere, even in the middle of a noteon message! 
+   * Real-time range: 0xF8 .. 0xFF
+   * Note: Real-time does not affect (running) status.
+   */  
+  if (c >= 0xF8){
+    if (c == MIDI_SYSTEM_RESET){
+      parser->event.type = c;
+      parser->status = 0; /* clear the status */
+      return &parser->event;
+    };
+    return NULL;
+  };
+
+  /*********************************************************************/
+  /* 'Process' system common messages (again, just skip them)          */
+  /*********************************************************************/
+  /* There are no system common messages that are of interest here.
+   * System common range: 0xF0 .. 0xF7 
+   */
+
+  if (c > 0xF0){
+    /* MIDI specs say: To ignore a non-real-time message, just discard all data
+     * up to the next status byte.  And our parser will ignore data that is
+     * received without a valid status.  
+     * Note: system common cancels running status. */
+    parser->status = 0;
+    return NULL;
+  };
+
+  /*********************************************************************/
+  /* Process voice category messages:                                  */
+  /*********************************************************************/
+  /* Now that we have handled realtime and system common messages, only
+   * voice messages are left.
+   * Only a status byte has bit # 7 set.
+   * So no matter the status of the parser (in case we have lost sync),
+   * as soon as a byte >= 0x80 comes in, we are dealing with a status byte
+   * and start a new event.
+   */
+
+  if (c & 0x80){
+    parser->channel = c & 0x0F;
+    parser->status = c & 0xF0;
+    /* The event consumes x bytes of data... (subtract 1 for the status 
+     * byte) */
+    parser->nr_bytes_total=aubio_midi_event_length(parser->status)-1;
+    /* of which we have read 0 at this time. */
+    parser->nr_bytes = 0;
+    return NULL;
+  };
+
+  /*********************************************************************/
+  /* Process data                                                      */
+  /*********************************************************************/
+  /* If we made it this far, then the received char belongs to the data
+   * of the last event. */
+  if (parser->status == 0){
+    /* We are not interested in the event currently received.
+     * Discard the data. */
+    return NULL;
+  };
+
+  /* Store the first couple of bytes */
+  if (parser->nr_bytes < AUBIO_MIDI_PARSER_MAX_PAR){
+    parser->p[parser->nr_bytes]=c;
+  };
+  parser->nr_bytes++;
+
+  /* Do we still need more data to get this event complete? */
+  if (parser->nr_bytes < parser->nr_bytes_total){
+    return NULL;
+  };
+
+  /*********************************************************************/
+  /* Send the event                                                    */
+  /*********************************************************************/
+  /* The event is ready-to-go.  About 'running status': 
+   * 
+   * The MIDI protocol has a built-in compression mechanism. If several similar
+   * events are sent in-a-row, for example note-ons, then the event type is
+   * only sent once. For this case, the last event type (status) is remembered.
+   * We simply keep the status as it is, just reset the parameter counter. If
+   * another status byte comes in, it will overwrite the status. 
+   */
+  parser->event.type = parser->status;
+  parser->event.channel = parser->channel;
+  parser->nr_bytes = 0; /* Related to running status! */
+  switch (parser->status){
+    case NOTE_OFF:
+    case NOTE_ON:
+    case KEY_PRESSURE:
+    case CONTROL_CHANGE:
+    case PROGRAM_CHANGE:
+    case CHANNEL_PRESSURE:
+      parser->event.param1 = parser->p[0]; /* For example key number */
+      parser->event.param2 = parser->p[1]; /* For example velocity */
+      break;
+    case PITCH_BEND:
+      /* Pitch-bend is transmitted with 14-bit precision. */
+      /* Note: '|' does here the same as '+' (no common bits), 
+       * but might be faster */
+      parser->event.param1 = ((parser->p[1] << 7) | parser->p[0]); 
+      break;
+    default: 
+      /* Unlikely */
+      return NULL;
+  };
+  return &parser->event;
+};
+
+
+
+/* Taken from Nagano Daisuke's USB-MIDI driver */
+static int remains_f0f6[] = {
+  0,	/* 0xF0 */
+  2,	/* 0XF1 */
+  3,	/* 0XF2 */
+  2,	/* 0XF3 */
+  2,	/* 0XF4 (Undefined by MIDI Spec, and subject to change) */
+  2,	/* 0XF5 (Undefined by MIDI Spec, and subject to change) */
+  1	  /* 0XF6 */
+};
+
+static int remains_80e0[] = {
+  3,	/* 0x8X Note Off */
+  3,	/* 0x9X Note On */
+  3,	/* 0xAX Poly-key pressure */
+  3,	/* 0xBX Control Change */
+  2,	/* 0xCX Program Change */
+  2,	/* 0xDX Channel pressure */
+  3 	/* 0xEX PitchBend Change */
+};
+
+/** Returns the length of the MIDI message starting with c.
+ *
+ * Taken from Nagano Daisuke's USB-MIDI driver */
+int aubio_midi_event_length(unsigned char event){
+  if ( event < 0xf0 ) {
+    return remains_80e0[((event-0x80)>>4)&0x0f];
+  } else if ( event < 0xf7 ) {
+    return remains_f0f6[event-0xf0];
+  } else {
+    return 1;
+  }
+}
