Standard MIDI FIle (SMF) Format 1.0

Header Chunk

Track Chunk

[Track Chunk]

• • •

SMF = <header_chunk> + <track_chunk> [+ <track_chunk> ...]

• The track ID string which is four charcters long. For example, header chunk IDs are "MThd", and Track chunk IDs are "MTrk".
• next is a four-byte unsigned value that specifies the number of bytes in the data section of the track (part 3).
• finally comes the data section of the chunk. The size of the data is specified in the length field which follows the chunk ID (part 2).

header_chunk = "MThd" + <header_length> + <format> + <n> + <division>

• Format 0 MIDI files consist of a header-chunk and a single track-chunk.
• Format 1 MIDI files consist of a header-chunk and one or more track-chunks, with all tracks being played simultaneously.
• Format 2 MIDI files consist of a header-chunk and one or more track-chunks, where each track represents an independant sequence.

TRack header Chunk

A track may contain up to 16 MIDI channels

<Track Chunk> = <chunk type> <length> <MTrk event>+<MTrk event>+...

<MTrk event> = <delta-time> <event>

<delta-time> is stored as a variable-length quantity. It represents the amount of time before the following event.
<event> = <MIDI event> | <sysex event> | <meta-event>

<meta-event>

Some numbers in MIDI Files are represented in a form called a variable-length quantity, e.g. <delta-time>. These numbers are represented 7 bits per byte, most significant bits first. All bytes except the last have bit 7 set, and the last byte has bit 7 clear. If the number is between 0 and 127, it is thus represented exactly as one byte.

Here are some examples of numbers represented as variable-length quantities:

   // Take the input 'value' and prepare for output in 'buffer'.
   // Go from the least significant byte in 'value' (the rightmost byte) and 
   // build 'buffer' in reverse byte order, i.e. the least significant
   // byte to the left.

   WriteVarLen (long value)
   {
     long buffer;                // the encoded format in reverse order
     buffer = value & 0x7f;    
     while ((value >>= 7) > 0)   // build buffer
     {
       buffer <<= 8;             // shift to left by 8 bits (one byte)
       buffer |= 0x80;           // set the leftmost bit
       buffer += (value & 0x7f); // strip the leftmost bit then add
     }
     while (1) // output section
     {
       putc(buffer, outfile); // ouput rightmost byte
       if (buffer & 0x80)     // if not the last byte (leftmost bit is zero)
         buffer >>= 8;        // get the next byte
       else
         break;
     }
  }

  unsigned long ReadVarLen (void)
  {
    unsigned long value;
    char c;
    if ((value = getc(infile)) & 0x80) // if more than one byte
    {
      value &= 0x7F;       // strip the lefmost bit
      do                   // shift left 7 bits and add the next byte
      {                    // without the leftmost bit 
         value = (value << 7) + ((c = getc(infile)) & 0x7F);
      } while (c & 0x80); // while not the last byte
    }
    return value;
  }