MIDI Format

Overview

MIDI (Musical Instrument Digital Interface) is a technical standard that describes a communications protocol, digital interface, and electrical connectors for connecting musical instruments, computers, and audio equipment. MIDI files contain musical performance data rather than actual audio, making them extremely compact while preserving detailed musical information.

File Format Details

File Extensions

• .mid (standard MIDI file)
• .midi (alternative extension)
• .rmi (RIFF MIDI format)
• .kar (karaoke MIDI files)

MIME Type

• audio/midi
• audio/x-midi
• application/x-midi

Format Specifications

• Type: Binary musical data format
• Structure: Header chunk followed by track chunks
• Timing: Time-based events using ticks
• Channels: 16 MIDI channels per port
• Resolution: Variable timing resolution (ticks per quarter note)

Technical Specifications

MIDI File Structure

MIDI File = Header Chunk + Track Chunk(s)

Header Chunk:
- "MThd" (4 bytes) - Chunk type
- Length (4 bytes) - Always 6
- Format (2 bytes) - 0, 1, or 2
- Tracks (2 bytes) - Number of track chunks
- Division (2 bytes) - Time division

Track Chunk:
- "MTrk" (4 bytes) - Chunk type
- Length (4 bytes) - Track data length
- Track Data - MIDI events with timing

MIDI Message Types

Channel Messages (0x80-0xEF):
- Note Off (0x80): Stop playing note
- Note On (0x90): Start playing note
- Polyphonic Pressure (0xA0): Key pressure
- Control Change (0xB0): Controller values
- Program Change (0xC0): Instrument selection
- Channel Pressure (0xD0): Channel pressure
- Pitch Bend (0xE0): Pitch wheel

System Messages (0xF0-0xFF):
- System Exclusive (0xF0): Manufacturer-specific
- Time Code (0xF1): SMPTE time code
- Song Position (0xF2): Song position pointer
- Song Select (0xF3): Song number
- System Reset (0xFF): Reset all devices

File Format Types

• Format 0: Single track containing all channels
• Format 1: Multiple tracks, synchronous playback
• Format 2: Multiple tracks, asynchronous sequences

History and Development

Timeline

• 1981: MIDI specification development begins
• 1983: MIDI 1.0 specification released
• 1988: Standard MIDI File (SMF) format introduced
• 1991: General MIDI (GM) standard established
• 1999: MIDI 2.0 development starts
• 2020: MIDI 2.0 specification finalized
• Present: Continued evolution with modern DAWs

Key Milestones

• Revolutionary standardization of electronic instruments
• Adoption by major synthesizer manufacturers
• Integration with computer music software
• Development of General MIDI instrument mapping
• Modern MIDI 2.0 with enhanced capabilities

Common Use Cases

Music Production

• Digital Audio Workstation (DAW) sequences
• Multi-track musical arrangements
• Virtual instrument control
• Automation and parameter control
• Musical notation input

Live Performance

• Keyboard controller data
• Drum machine programming
• Lighting control synchronization
• Stage equipment automation
• Real-time effects control

Educational Applications

• Music theory instruction
• Piano learning software
• Composition exercises
• Music analysis tools
• Interactive music lessons

Technical Implementation

MIDI File Parsing (Python)

import struct
from typing import List, Tuple, Dict

class MIDIEvent:
    def __init__(self, delta_time: int, event_type: int, data: bytes):
        self.delta_time = delta_time
        self.event_type = event_type
        self.data = data
    
    def __repr__(self):
        return f"MIDIEvent(dt={self.delta_time}, type=0x{self.event_type:02X}, data={self.data.hex()})"

class MIDIParser:
    def __init__(self):
        self.tracks = []
        self.format_type = 0
        self.time_division = 480
    
    def parse_file(self, filename: str) -> Dict:
        with open(filename, 'rb') as f:
            # Parse header chunk
            header = self._parse_header(f)
            
            # Parse track chunks
            tracks = []
            for i in range(header['num_tracks']):
                track = self._parse_track(f)
                tracks.append(track)
            
            return {
                'header': header,
                'tracks': tracks
            }
    
    def _parse_header(self, f) -> Dict:
        chunk_type = f.read(4)
        if chunk_type != b'MThd':
            raise ValueError("Invalid MIDI file - missing MThd header")
        
        length = struct.unpack('>I', f.read(4))[0]
        format_type = struct.unpack('>H', f.read(2))[0]
        num_tracks = struct.unpack('>H', f.read(2))[0]
        time_division = struct.unpack('>H', f.read(2))[0]
        
        return {
            'format_type': format_type,
            'num_tracks': num_tracks,
            'time_division': time_division
        }
    
    def _parse_track(self, f) -> List[MIDIEvent]:
        chunk_type = f.read(4)
        if chunk_type != b'MTrk':
            raise ValueError("Invalid track chunk")
        
        track_length = struct.unpack('>I', f.read(4))[0]
        track_data = f.read(track_length)
        
        return self._parse_track_events(track_data)
    
    def _parse_track_events(self, data: bytes) -> List[MIDIEvent]:
        events = []
        pos = 0
        running_status = 0
        
        while pos < len(data):
            # Parse variable-length delta time
            delta_time, pos = self._read_variable_length(data, pos)
            
            # Parse event
            if pos >= len(data):
                break
                
            event_byte = data[pos]
            pos += 1
            
            if event_byte & 0x80:  # Status byte
                running_status = event_byte
            else:  # Data byte, use running status
                pos -= 1
                event_byte = running_status
            
            # Parse different event types
            if event_byte == 0xFF:  # Meta event
                meta_type = data[pos]
                pos += 1
                length, pos = self._read_variable_length(data, pos)
                event_data = data[pos:pos+length]
                pos += length
                
                events.append(MIDIEvent(delta_time, 0xFF, 
                                      bytes([meta_type]) + event_data))
            
            elif event_byte & 0xF0 in [0x80, 0x90, 0xA0, 0xB0, 0xE0]:
                # Two-byte channel messages
                param1 = data[pos] if pos < len(data) else 0
                param2 = data[pos + 1] if pos + 1 < len(data) else 0
                pos += 2
                
                events.append(MIDIEvent(delta_time, event_byte, 
                                      bytes([param1, param2])))
            
            elif event_byte & 0xF0 in [0xC0, 0xD0]:
                # One-byte channel messages
                param = data[pos] if pos < len(data) else 0
                pos += 1
                
                events.append(MIDIEvent(delta_time, event_byte, 
                                      bytes([param])))
        
        return events
    
    def _read_variable_length(self, data: bytes, pos: int) -> Tuple[int, int]:
        value = 0
        while pos < len(data):
            byte = data[pos]
            pos += 1
            value = (value << 7) | (byte & 0x7F)
            if not (byte & 0x80):
                break
        return value, pos

# Usage example
parser = MIDIParser()
midi_data = parser.parse_file('example.mid')
print(f"Format: {midi_data['header']['format_type']}")
print(f"Tracks: {midi_data['header']['num_tracks']}")
print(f"Time Division: {midi_data['header']['time_division']}")

MIDI Event Processing

def analyze_midi_events(events: List[MIDIEvent]) -> Dict:
    """Analyze MIDI events for musical information"""
    analysis = {
        'note_events': [],
        'tempo_changes': [],
        'program_changes': [],
        'control_changes': [],
        'total_time': 0
    }
    
    current_time = 0
    active_notes = {}
    
    for event in events:
        current_time += event.delta_time
        event_type = event.event_type & 0xF0
        channel = event.event_type & 0x0F
        
        if event_type == 0x90 and len(event.data) >= 2:  # Note On
            note = event.data[0]
            velocity = event.data[1]
            if velocity > 0:
                active_notes[(channel, note)] = {
                    'start_time': current_time,
                    'velocity': velocity
                }
            else:  # Note On with velocity 0 = Note Off
                if (channel, note) in active_notes:
                    start_info = active_notes.pop((channel, note))
                    analysis['note_events'].append({
                        'channel': channel,
                        'note': note,
                        'start_time': start_info['start_time'],
                        'end_time': current_time,
                        'duration': current_time - start_info['start_time'],
                        'velocity': start_info['velocity']
                    })
        
        elif event_type == 0x80 and len(event.data) >= 2:  # Note Off
            note = event.data[0]
            if (channel, note) in active_notes:
                start_info = active_notes.pop((channel, note))
                analysis['note_events'].append({
                    'channel': channel,
                    'note': note,
                    'start_time': start_info['start_time'],
                    'end_time': current_time,
                    'duration': current_time - start_info['start_time'],
                    'velocity': start_info['velocity']
                })
        
        elif event_type == 0xC0 and len(event.data) >= 1:  # Program Change
            program = event.data[0]
            analysis['program_changes'].append({
                'time': current_time,
                'channel': channel,
                'program': program
            })
        
        elif event.event_type == 0xFF and len(event.data) >= 1:  # Meta event
            meta_type = event.data[0]
            if meta_type == 0x51 and len(event.data) >= 4:  # Tempo
                tempo = struct.unpack('>I', b'\x00' + event.data[1:4])[0]
                bpm = 60000000 / tempo
                analysis['tempo_changes'].append({
                    'time': current_time,
                    'tempo': tempo,
                    'bpm': bpm
                })
    
    analysis['total_time'] = current_time
    return analysis

MIDI Creation Example

def create_simple_midi(notes: List[Tuple[int, int, int]], filename: str):
    """Create a simple MIDI file from note data"""
    
    def write_variable_length(value: int) -> bytes:
        """Write variable-length quantity"""
        result = []
        result.append(value & 0x7F)
        value >>= 7
        while value:
            result.append((value & 0x7F) | 0x80)
            value >>= 7
        return bytes(reversed(result))
    
    # MIDI header
    header = b'MThd' + struct.pack('>I', 6) + struct.pack('>HHH', 0, 1, 480)
    
    # Track data
    track_events = []
    
    # Add notes
    for note, velocity, duration in notes:
        # Note On
        track_events.append((0, 0x90, note, velocity))
        # Note Off
        track_events.append((duration, 0x80, note, 0))
    
    # Sort by time
    track_events.sort(key=lambda x: x[0])
    
    # Build track chunk
    track_data = b''
    last_time = 0
    
    for time, status, data1, data2 in track_events:
        delta_time = time - last_time
        last_time = time
        
        track_data += write_variable_length(delta_time)
        track_data += bytes([status, data1, data2])
    
    # End of track
    track_data += write_variable_length(0) + b'\xFF\x2F\x00'
    
    # Track chunk header
    track_chunk = b'MTrk' + struct.pack('>I', len(track_data)) + track_data
    
    # Write file
    with open(filename, 'wb') as f:
        f.write(header + track_chunk)
    
    print(f"Created MIDI file: {filename}")

# Usage
notes = [
    (60, 100, 480),  # C4, velocity 100, quarter note
    (64, 100, 480),  # E4, velocity 100, quarter note
    (67, 100, 480),  # G4, velocity 100, quarter note
    (72, 100, 960),  # C5, velocity 100, half note
]

create_simple_midi(notes, 'simple_chord.mid')

Tools and Software

Digital Audio Workstations (DAWs)

• Pro Tools: Industry-standard recording software
• Logic Pro: Apple's professional DAW
• Cubase: Steinberg's comprehensive DAW
• Ableton Live: Performance-oriented DAW
• FL Studio: Pattern-based music production

MIDI Utilities

• MIDIUtil: Python library for MIDI file creation
• pretty_midi: Python library for MIDI analysis
• FluidSynth: Software synthesizer for MIDI playback
• TiMidity++: MIDI to audio converter
• MIDI-OX: Windows MIDI utility

Hardware Controllers

• MIDI keyboards: Note input and control
• MIDI controllers: Knobs, faders, and buttons
• Drum pads: Percussion input devices
• MIDI interfaces: USB and traditional MIDI ports
• Software instruments: Virtual synthesizers and samplers

Best Practices

MIDI Programming

• Use appropriate velocity values for realistic expression
• Implement proper timing and quantization
• Organize tracks by instrument or musical part
• Include tempo and time signature information

Performance Optimization

class MIDIOptimizer:
    @staticmethod
    def remove_duplicate_events(events: List[MIDIEvent]) -> List[MIDIEvent]:
        """Remove redundant MIDI events"""
        optimized = []
        last_program = {}
        last_controller = {}
        
        for event in events:
            event_type = event.event_type & 0xF0
            channel = event.event_type & 0x0F
            
            if event_type == 0xC0:  # Program Change
                program = event.data[0] if event.data else 0
                if last_program.get(channel) != program:
                    optimized.append(event)
                    last_program[channel] = program
            
            elif event_type == 0xB0:  # Control Change
                if len(event.data) >= 2:
                    controller = event.data[0]
                    value = event.data[1]
                    key = (channel, controller)
                    if last_controller.get(key) != value:
                        optimized.append(event)
                        last_controller[key] = value
            
            else:
                optimized.append(event)
        
        return optimized
    
    @staticmethod
    def quantize_timing(events: List[MIDIEvent], 
                       quantize_resolution: int = 120) -> List[MIDIEvent]:
        """Quantize MIDI timing to nearest grid"""
        quantized = []
        
        for event in events:
            quantized_delta = round(event.delta_time / quantize_resolution) * quantize_resolution
            quantized_event = MIDIEvent(quantized_delta, event.event_type, event.data)
            quantized.append(quantized_event)
        
        return quantized

File Organization

• Use descriptive track names
• Include copyright and title metadata
• Set appropriate tempo markings
• Use standard General MIDI instrument assignments

Security Considerations

File Validation

• Validate MIDI file structure before processing
• Check for malformed variable-length quantities
• Limit file size to prevent memory exhaustion
• Validate track chunk lengths

Safe Processing

def safe_midi_parse(filename: str, max_file_size: int = 10*1024*1024) -> Dict:
    """Safely parse MIDI file with size limits"""
    
    # Check file size
    file_size = os.path.getsize(filename)
    if file_size > max_file_size:
        raise ValueError(f"MIDI file too large: {file_size} bytes")
    
    # Validate file signature
    with open(filename, 'rb') as f:
        header = f.read(4)
        if header != b'MThd':
            raise ValueError("Invalid MIDI file signature")
        
        # Parse with error handling
        try:
            parser = MIDIParser()
            return parser.parse_file(filename)
        except struct.error:
            raise ValueError("Corrupted MIDI file structure")
        except MemoryError:
            raise ValueError("MIDI file too complex to process")

Data Sanitization

• Filter potentially harmful system exclusive messages
• Validate note ranges and parameter values
• Implement timeout mechanisms for long files
• Sanitize metadata strings

Integration Examples

Web MIDI Player

// Web MIDI API example
class WebMIDIPlayer {
    constructor() {
        this.midiAccess = null;
        this.outputs = [];
    }
    
    async initialize() {
        try {
            this.midiAccess = await navigator.requestMIDIAccess();
            this.outputs = Array.from(this.midiAccess.outputs.values());
            console.log(`Found ${this.outputs.length} MIDI outputs`);
        } catch (error) {
            console.error('MIDI access denied:', error);
        }
    }
    
    playNote(note, velocity = 100, duration = 500) {
        if (this.outputs.length === 0) return;
        
        const output = this.outputs[0];
        const channel = 0;
        
        // Note On
        output.send([0x90 | channel, note, velocity]);
        
        // Note Off after duration
        setTimeout(() => {
            output.send([0x80 | channel, note, 0]);
        }, duration);
    }
    
    playChord(notes, velocity = 100, duration = 1000) {
        notes.forEach(note => this.playNote(note, velocity, duration));
    }
}

// Usage
const player = new WebMIDIPlayer();
await player.initialize();
player.playChord([60, 64, 67], 100, 2000); // C major chord

MIDI to Audio Conversion

import subprocess
import tempfile

def midi_to_audio(midi_file: str, output_file: str, 
                 soundfont: str = None) -> bool:
    """Convert MIDI to audio using FluidSynth"""
    
    try:
        cmd = ['fluidsynth', '-ni']
        
        if soundfont:
            cmd.extend([soundfont])
        else:
            # Use default system soundfont
            cmd.extend(['/usr/share/sounds/sf2/FluidR3_GM.sf2'])
        
        cmd.extend([midi_file, '-F', output_file, '-r', '44100'])
        
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
        
        if result.returncode == 0:
            print(f"Successfully converted {midi_file} to {output_file}")
            return True
        else:
            print(f"Conversion failed: {result.stderr}")
            return False
            
    except subprocess.TimeoutExpired:
        print("Conversion timed out")
        return False
    except FileNotFoundError:
        print("FluidSynth not found - please install FluidSynth")
        return False

# Usage
success = midi_to_audio('input.mid', 'output.wav', 'soundfont.sf2')

MIDI remains a fundamental standard in digital music, providing efficient musical data representation and enabling seamless communication between diverse musical instruments, software, and hardware systems across the music production industry.