source: ext/midi/midi_parser.c @ 028c8e9

/* 
 * 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;
  }
}