Simple MIDI input

Basic MIDI input

#include <sys/soundcard.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

#define  MIDI_DEVICE  "/dev/sequencer"


int main(void) {
   unsigned char inpacket[4];

   // first open the sequencer device for reading.
   int seqfd = open(MIDI_DEVICE, O_RDONLY);
   if (seqfd == -1) {
      printf("Error: cannot open %s\n", MIDI_DEVICE);
      exit(1);
   } 

   // now just wait around for MIDI bytes to arrive and print them to screen.
   while (1) {
      read(seqfd, &inpacket, sizeof(inpacket));
 
      // print the MIDI byte if this input packet contains one
      if (inpacket[0] == SEQ_MIDIPUTC) {
         printf("received MIDI byte: %d\n", inpacket[1]);
      }
   }
      
   return 0;
}

Example 1 is not very useful unless you only want to read MIDI input and do nothing else. The line "read(seqfd, &inpacket, sizeof(inpacket));" will not continue until there is some data to be read from MIDI input.

The following figure shows some sample output from the Example 1 program when playing 5 notes on a Yamaha Disklavier hooked up to the MIDI input port on the computer:

Example screen display from supersimplein.c program:


          received MIDI byte: 144
          received MIDI byte: 60 
          received MIDI byte: 46 
          received MIDI byte: 60 
          received MIDI byte: 0  
          received MIDI byte: 62 
          received MIDI byte: 43 
          received MIDI byte: 62 
          received MIDI byte: 0  
          received MIDI byte: 64 
          received MIDI byte: 54 
          received MIDI byte: 64 
          received MIDI byte: 0  
          received MIDI byte: 65 
          received MIDI byte: 44 
          received MIDI byte: 65 
          received MIDI byte: 0  
          received MIDI byte: 67 
          received MIDI byte: 62 
          received MIDI byte: 67 
          received MIDI byte: 0

Musical Interpretation:

In case you are not familiar with the MIDI protocol, here are some essentials to know. For the example above, 144 is a note-on command which expected two data bytes to follow. The next byte is the note-on's key number (60 = middle C), and next is the attack velocity (46), which is how hard the note was played. The fourth byte is a data byte since it is less than 128. Therefore the data is now in running status which means apply the last MIDI command (which was 144 to the data, so the key number is again 60. The next byte (0) is the attack velocity which in this case actually represents a note-off. etc.

The MIDI protocol does not specify timing, so the durations of the notes in the example above are undefined for now. Section 2 example programs show how timing is handled with MIDI input.

Threads

The standard method for handling MIDI input while doing other things in a program in UNIX is using threads. Threads are used to simulate multiple processes while only using one CPU. Example 2 shows how to incorporate threads into a simple MIDI input reader which has the same functionality as Example 1.

Example 2: simplein.c

#include <stdio.h>
#include <sys/soundcard.h>
#include <fcntl.h>
#include <unistd.h>

#include <pthread.h >        /* for MIDI input interpreter thread */

#define  MIDI_DEVICE  "/dev/sequencer"

// global variables:
int                         seqfd;          // sequencer file descriptor
pthread_t                   midiInThread;   // thread blocker for midi input


// function declarations
void* threadFunction(void*);    // thread function for MIDI input interpreter


int main(void) {
   int status;            // for error checking

   // (1) first open the sequencer device for reading.
   //     some examples also have a nonblocking options in 2nd param

   seqfd = open(MIDI_DEVICE, O_RDONLY);
   if (seqfd == -1) {
      printf("Error: cannot open %s\n", MIDI_DEVICE);
      exit(1);
   } 


   // (2) now start the thread that interpreting incoming MIDI bytes:

   status = pthread_create(&midiInThread, NULL, threadFunction, NULL);
   if (status == -1) {
      printf("Error: unable to create MIDI input thread.\n");
      exit(1);
   } 


   // (3) finally, just wait around for MIDI messages to appear in the
   // input buffer and print them to the screen.

   while (1) {
      // do nothing, just wait around for thread function.
   }

   return 0;
}



//////////////////////////////
//
// threadFunction -- this function is sent to the pthread library
//    functions for running as a separate thread.
//

void* threadFunction(void* x) {
   unsigned char inbytes[4];         // bytes from sequencer driver
   int status;               // for error checking

   while (1) {
      status = read(seqfd, &inbytes, sizeof(inbytes));
      if (status < 0) {
         printf("Error reading %s\n", MIDI_DEVICE);
         exit(1);
      }
 
      if (inbytes[0] == SEQ_MIDIPUTC) {
         printf("received MIDI byte: %d\n", inbytes[1]);
      }
   }
}

The thread functions of interest for MIDI input are:

int pthread_create(pthread*, pthread_attr_t*, void* function(void*), void*);

This function sets up a thread by running the function passed as parameter 3. The parameters are:

a pthread structure -- which the pthread functions use for maintaining the thread.
attributes for the thread which is set to NULL for default values.
the thread function -- this is the function which will run independently.
arguments to the thread -- NULL since there are none for this example.

void* threadFunction(void* x);

The name of this function is arbitrary, however, this function is the function which is run when pthread_create is called.

craig@ccrma.stanford.edu