audio-mixer-engine 0.1.0

package/src/lib/midi-parser.js

@@ -0,0 +1,718 @@
+/**
+ * MidiParser - A class for parsing MIDI files
+ * Extracts parts, bar structure, and metadata
+ */
+class MidiParser {
+  constructor() {
+    // Common part names to detect
+    this.partNames = [
+      'soprano', 'alto', 'tenor', 'bass', 
+      'treble', 'mezzo', 'baritone',
+      's', 'a', 't', 'b', 'satb'
+    ];
+    
+    // Store the parsed data
+    this.parsedData = {
+      parts: {},       // Will contain separate arrays for each vocal part
+      barStructure: [], // Will contain bar timing information
+      metadata: {}     // Will contain title, composer, etc.
+    };
+  }
+
+  /**
+   * Main method to parse a MIDI file
+   * @param {ArrayBuffer} midiFileBuffer - The MIDI file as an ArrayBuffer
+   * @returns {Object} Parsed data with parts, barStructure and metadata
+   */
+  async parse(midiFileBuffer) {
+    try {
+      const midi = await this._parseMidiBuffer(midiFileBuffer);
+      
+      // Extract metadata
+      this._extractMetadata(midi);
+      
+      // Extract bar structure (time signatures, tempo changes)
+      this._extractBarStructure(midi);
+      
+      // Extract parts
+      this._extractParts(midi);
+      
+      return this.parsedData;
+    } catch (error) {
+      console.error('Error parsing MIDI file:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Parse the MIDI buffer into a workable format
+   * @private
+   */
+  async _parseMidiBuffer(midiFileBuffer) {
+    // Convert ArrayBuffer to Uint8Array
+    const data = new Uint8Array(midiFileBuffer);
+    
+    // Check if it's a valid MIDI file
+    if (!(data[0] === 0x4D && data[1] === 0x54 && data[2] === 0x68 && data[3] === 0x64)) {
+      throw new Error('Not a valid MIDI file');
+    }
+    
+    // Parse header chunk
+    const headerLength = this._bytesToNumber(data.slice(4, 8));
+    const format = this._bytesToNumber(data.slice(8, 10));
+    const tracksCount = this._bytesToNumber(data.slice(10, 12));
+    const division = this._bytesToNumber(data.slice(12, 14));
+    
+    // MIDI time division (ticks per quarter note or SMPTE)
+    const ticksPerBeat = division & 0x8000 ? null : division;
+    
+    const midi = {
+      format,
+      ticksPerBeat,
+      tracks: [],
+      duration: 0
+    };
+    
+    // Parse each track
+    let currentPosition = 8 + headerLength;
+    for (let i = 0; i < tracksCount; i++) {
+      if (data[currentPosition] === 0x4D && data[currentPosition + 1] === 0x54 && 
+          data[currentPosition + 2] === 0x72 && data[currentPosition + 3] === 0x6B) {
+        
+        const trackLength = this._bytesToNumber(data.slice(currentPosition + 4, currentPosition + 8));
+        const trackData = data.slice(currentPosition + 8, currentPosition + 8 + trackLength);
+        
+        const track = this._parseTrack(trackData);
+        midi.tracks.push(track);
+        
+        currentPosition += 8 + trackLength;
+      } else {
+        throw new Error(`Invalid track header at position ${currentPosition}`);
+      }
+    }
+    
+    return midi;
+  }
+  
+  /**
+   * Parse a single MIDI track
+   * @private
+   */
+  _parseTrack(data) {
+    const track = {
+      notes: [],
+      name: null,
+      lyrics: [],
+      events: [],
+      duration: 0
+    };
+
+    let currentPosition = 0;
+    let currentTick = 0;
+    let runningStatus = null;
+    
+    while (currentPosition < data.length) {
+      // Parse delta time
+      let deltaTime = 0;
+      let byte = 0;
+      // noinspection JSBitwiseOperatorUsage
+      do {
+        byte = data[currentPosition++];
+        deltaTime = (deltaTime << 7) | (byte & 0x7F);
+      } while (byte & 0x80);
+      
+      currentTick += deltaTime;
+      
+      // Get event type
+      byte = data[currentPosition++];
+      let eventType = byte;
+      
+      // Handle running status
+      if ((byte & 0x80) === 0) {
+        if (runningStatus === null) {
+          throw new Error("Running status byte encountered before status byte");
+        }
+        eventType = runningStatus;
+        currentPosition--; // We need to reread the current byte as a data byte
+      } else {
+        runningStatus = eventType;
+      }
+      
+      // Handle different event types
+      if (eventType === 0xFF) { // Meta event
+        const metaType = data[currentPosition++];
+        const metaLength = this._readVariableLengthValue(data, currentPosition);
+        currentPosition += metaLength.bytesRead;
+        const metaData = data.slice(currentPosition, currentPosition + metaLength.value);
+        currentPosition += metaLength.value;
+        
+        // Handle meta events
+        switch (metaType) {
+          case 0x03: // Track name
+            track.name = this._bytesToString(metaData);
+            break;
+          case 0x01: // Text event
+            track.events.push({
+              type: 'text',
+              text: this._bytesToString(metaData),
+              tick: currentTick
+            });
+            break;
+          case 0x05: // Lyrics
+            track.lyrics.push({
+              text: this._bytesToString(metaData),
+              tick: currentTick
+            });
+            break;
+          case 0x51: // Tempo
+            const microsecondsPerBeat = this._bytesToNumber(metaData);
+            const tempo = Math.round(60000000 / microsecondsPerBeat);
+            track.events.push({
+              type: 'tempo',
+              bpm: tempo,
+              tick: currentTick
+            });
+            break;
+          case 0x58: // Time signature
+            track.events.push({
+              type: 'timeSignature',
+              numerator: metaData[0],
+              denominator: Math.pow(2, metaData[1]),
+              tick: currentTick
+            });
+            break;
+          case 0x2F: // End of track
+            track.duration = currentTick;
+            break;
+        }
+      } 
+      else if ((eventType & 0xF0) === 0x90) { // Note on
+        const channel = eventType & 0x0F;
+        const noteNumber = data[currentPosition++];
+        const velocity = data[currentPosition++];
+        
+        if (velocity > 0) { // Note on with velocity > 0
+          track.notes.push({
+            type: 'noteOn',
+            noteNumber,
+            velocity,
+            tick: currentTick,
+            channel
+          });
+        } else { // Note on with velocity = 0 is equivalent to note off
+          track.notes.push({
+            type: 'noteOff',
+            noteNumber,
+            tick: currentTick,
+            channel
+          });
+        }
+      } 
+      else if ((eventType & 0xF0) === 0x80) { // Note off
+        const channel = eventType & 0x0F;
+        const noteNumber = data[currentPosition++];
+        // noinspection JSUnusedLocalSymbols
+        const velocity = data[currentPosition++]; // Release velocity, intentionally ignored (maybe for now)
+        
+        track.notes.push({
+          type: 'noteOff',
+          noteNumber,
+          tick: currentTick,
+          channel
+        });
+      }
+      else if (eventType === 0xF0 || eventType === 0xF7) { // SysEx events
+        const length = this._readVariableLengthValue(data, currentPosition);
+        currentPosition += length.bytesRead + length.value;
+      }
+      else if ((eventType & 0xF0) === 0xB0) { // Controller change
+        const channel = eventType & 0x0F;
+        const controllerNumber = data[currentPosition++];
+        const value = data[currentPosition++];
+        
+        track.events.push({
+          type: 'controller',
+          controllerNumber,
+          value,
+          channel,
+          tick: currentTick
+        });
+      }
+      else if ((eventType & 0xF0) === 0xC0) { // Program change
+        const channel = eventType & 0x0F;
+        const programNumber = data[currentPosition++];
+        
+        track.events.push({
+          type: 'programChange',
+          programNumber,
+          channel,
+          tick: currentTick
+        });
+      }
+      else if ((eventType & 0xF0) === 0xD0) { // Channel aftertouch
+        const channel = eventType & 0x0F;
+        const pressure = data[currentPosition++];
+        
+        track.events.push({
+          type: 'channelAftertouch',
+          pressure,
+          channel,
+          tick: currentTick
+        });
+      }
+      else if ((eventType & 0xF0) === 0xE0) { // Pitch bend
+        const channel = eventType & 0x0F;
+        const lsb = data[currentPosition++];
+        const msb = data[currentPosition++];
+        const value = ((msb << 7) | lsb) - 8192; // Center value is 8192 (0x2000)
+        
+        track.events.push({
+          type: 'pitchBend',
+          value,
+          channel,
+          tick: currentTick
+        });
+      }
+      else if ((eventType & 0xF0) === 0xA0) { // Note aftertouch (poly pressure)
+        const channel = eventType & 0x0F;
+        const noteNumber = data[currentPosition++];
+        const pressure = data[currentPosition++];
+        
+        track.events.push({
+          type: 'noteAftertouch',
+          noteNumber,
+          pressure,
+          channel,
+          tick: currentTick
+        });
+      }
+      else {
+        // Skip unknown event types
+        console.warn(`Unknown event type: ${eventType.toString(16)} at position ${currentPosition - 1}`);
+        // Try to recover by skipping to the next event
+        currentPosition++;
+      }
+    }
+    
+    return track;
+  }
+
+  /**
+   * Extract metadata from the MIDI object
+   * @private
+   */
+  _extractMetadata(midi) {
+    const metadata = {
+      title: null,
+      composer: null,
+      partNames: [],
+      format: midi.format,
+      ticksPerBeat: midi.ticksPerBeat
+    };
+    
+    // Look for title, composer and part names in track names and text events
+    midi.tracks.forEach((track, index) => {
+      // First track with name is often the title
+      if (track.name && !metadata.title) {
+        metadata.title = track.name;
+      }
+      
+      // Check for common metadata in text events
+      track.events.filter(e => e.type === 'text').forEach(event => {
+        const text = event.text.toLowerCase();
+        if ((text.includes('compos') || text.includes('by')) && !metadata.composer) {
+          metadata.composer = event.text;
+        }
+      });
+      
+      // Store track name as potential part name
+      if (track.name) {
+        // Check if this track name matches a common choir part name
+        const trackNameLower = track.name.toLowerCase();
+        for (const partName of this.partNames) {
+          if (trackNameLower.includes(partName)) {
+            metadata.partNames.push({
+              index,
+              name: track.name
+            });
+            break;
+          }
+        }
+      }
+    });
+    
+    this.parsedData.metadata = metadata;
+  }
+
+  /**
+   * Extract bar structure (time signatures, tempo changes)
+   * New format: {"sig": [numerator, denominator], "bpm": tempo_or_array}
+   * @private
+   */
+  _extractBarStructure(midi) {
+    // Get ticks per beat for calculations
+    const ticksPerBeat = midi.ticksPerBeat || 480;
+    
+    // Collect all time signature and tempo changes
+    const allEvents = [];
+    midi.tracks.forEach(track => {
+      track.events.forEach(event => {
+        if (event.type === 'timeSignature' || event.type === 'tempo') {
+          allEvents.push(event);
+        }
+      });
+    });
+    
+    // Sort events by tick
+    allEvents.sort((a, b) => a.tick - b.tick);
+    
+    // Find total duration of the MIDI file (latest note end tick)
+    let totalDurationTicks = 0;
+    midi.tracks.forEach(track => {
+      if (track.notes) {
+        track.notes.forEach(note => {
+          if (note.type === 'noteOff' && note.tick > totalDurationTicks) {
+            totalDurationTicks = note.tick;
+          }
+        });
+      }
+    });
+    
+    // If no notes found, use a reasonable default
+    if (totalDurationTicks === 0) {
+      totalDurationTicks = ticksPerBeat * 8; // Default to 8 beats
+    }
+    
+    // Build bar structure based on time signature changes
+    const barStructure = [];
+
+    // Get all time signature changes with their positions
+    const timeSignatureChanges = allEvents
+      .filter(event => event.type === 'timeSignature')
+      .sort((a, b) => a.tick - b.tick);
+
+    // Start with the default (will be overridden if there is a time signature at tick 0)
+    let currentTimeSignature = { numerator: 4, denominator: 4 };
+
+    let currentTempo = 120; // Default tempo
+    let currentTick = 0;
+    let timeSignatureIndex = 0;
+
+    while (currentTick < totalDurationTicks) {
+      // Update time signature for the current position
+      while (timeSignatureIndex < timeSignatureChanges.length &&
+             timeSignatureChanges[timeSignatureIndex].tick <= currentTick) {
+        currentTimeSignature = timeSignatureChanges[timeSignatureIndex];
+        timeSignatureIndex++;
+      }
+
+      // For anacrusis/pickup bars, the bar should extend to the next time signature change
+      // For normal bars, use standard bar length
+      let barEndTick;
+
+      // Regular bar - use standard time signature-based length
+      barEndTick = currentTick + (ticksPerBeat * 4 * currentTimeSignature.numerator / currentTimeSignature.denominator);
+
+      // Find tempo changes within this bar
+      const barTempoChanges = allEvents.filter(event => 
+        event.type === 'tempo' && 
+        event.tick >= currentTick && 
+        event.tick < barEndTick
+      );
+      
+      // Build tempo array for each beat in the bar
+      const beatsInBar = currentTimeSignature.numerator;
+      const bpmArray = [];
+      
+      for (let beat = 0; beat < beatsInBar; beat++) {
+        const beatStartTick = currentTick + (beat * ticksPerBeat);
+        
+        // Find the effective tempo for this beat
+        let effectiveTempo = currentTempo; // Start with current tempo
+        
+        // Check for tempo changes that affect this beat
+        for (let i = barTempoChanges.length - 1; i >= 0; i--) {
+          const tempoChange = barTempoChanges[i];
+          if (tempoChange.tick <= beatStartTick) {
+            effectiveTempo = tempoChange.bpm;
+            break;
+          }
+        }
+        
+        // Also check for global tempo changes before this beat
+        for (let i = allEvents.length - 1; i >= 0; i--) {
+          const event = allEvents[i];
+          if (event.type === 'tempo' && event.tick <= beatStartTick) {
+            effectiveTempo = event.bpm;
+            // Update current tempo for next iterations
+            if (event.tick <= currentTick) {
+              currentTempo = event.bpm;
+            }
+            break;
+          }
+        }
+
+        // The bpm from the midi is crotchets (quarter notes) per minute, but we want
+        // time signature notes per minute, (i.e. if an x/2 signature then minims (half notes) per minute)
+        bpmArray.push(effectiveTempo * currentTimeSignature.denominator / 4);
+      }
+      
+      // If all beats have the same tempo, use single number; otherwise use array
+      const allSameTempo = bpmArray.every(tempo => tempo === bpmArray[0]);
+      const bpm = allSameTempo ? bpmArray[0] : bpmArray;
+      
+      barStructure.push({
+        sig: [currentTimeSignature.numerator, currentTimeSignature.denominator],
+        bpm: bpm
+      });
+      
+      // Move to next bar
+      currentTick = barEndTick;
+    }
+    
+    this.parsedData.barStructure = barStructure;
+  }
+
+  /**
+   * Extract notes for each voice part
+   * @private
+   */
+  _extractParts(midi) {
+    const parts = {};
+    const ticksPerBeat = midi.ticksPerBeat;
+    
+    
+    // Try to identify vocal parts by track name
+    midi.tracks.forEach((track, trackIndex) => {
+      if (!track.notes.length) return; // Skip tracks with no notes (e.g., conductor track)
+      
+      let partName = null;
+      
+      // Try to identify part name from track name
+      if (track.name) {
+        const lowerName = track.name.toLowerCase();
+        for (const name of this.partNames) {
+          // For single letters, require exact match; for words, allow includes
+          if (name.length === 1) {
+            if (lowerName === name) {
+              partName = name;
+              break;
+            }
+          } else {
+            if (lowerName.includes(name)) {
+              partName = name;
+              break;
+            }
+          }
+        }
+      }
+      
+      // If no recognized part name, use track name or track number
+      if (!partName) {
+        partName = track.name || `Track ${trackIndex + 1}`;
+      }
+      
+      // Normalize part name
+      if (partName === 's') partName = 'soprano';
+      if (partName === 'a') partName = 'alto';
+      if (partName === 't') partName = 'tenor';
+      if (partName === 'b') partName = 'bass';
+      
+      // Ensure unique part names by appending counter if name already exists
+      let uniquePartName = partName;
+      let counter = 2; // Start at 2 for first duplicate
+      while (parts[uniquePartName]) {
+        uniquePartName = `${partName} ${counter}`;
+        counter++;
+      }
+      partName = uniquePartName;
+      
+      // Process notes
+      const notes = [];
+      const noteOns = {};
+      
+      track.notes.forEach(noteEvent => {
+        if (noteEvent.type === 'noteOn') {
+          // Store note start information
+          noteOns[noteEvent.noteNumber] = {
+            tick: noteEvent.tick,
+            velocity: noteEvent.velocity
+          };
+        } else if (noteEvent.type === 'noteOff') {
+          // If we have a matching note on, create a complete note
+          if (noteOns[noteEvent.noteNumber]) {
+            const start = noteOns[noteEvent.noteNumber];
+            const duration = noteEvent.tick - start.tick;
+            
+            notes.push({
+              pitch: noteEvent.noteNumber,
+              name: this._midiNoteToName(noteEvent.noteNumber),
+              startTick: start.tick,
+              endTick: noteEvent.tick,
+              duration,
+              // Convert ticks to actual time considering tempo changes
+              startTime: this._ticksToTime(start.tick, midi),
+              endTime: this._ticksToTime(noteEvent.tick, midi),
+              velocity: start.velocity
+            });
+            
+            // Remove from active notes
+            delete noteOns[noteEvent.noteNumber];
+          }
+        }
+      });
+      
+      // Add any lyrics associated with this track
+      const lyrics = track.lyrics.map(lyric => ({
+        text: lyric.text,
+        tick: lyric.tick,
+        time: lyric.tick / ticksPerBeat // Time in quarter notes
+      }));
+      
+      // Sort notes by start time
+      notes.sort((a, b) => a.startTick - b.startTick);
+      
+      // Extract program changes for this track
+      const programChanges = track.events
+        .filter(event => event.type === 'programChange')
+        .map(event => ({
+          programNumber: event.programNumber,
+          tick: event.tick,
+          time: this._ticksToTime(event.tick, midi)
+        }))
+        .sort((a, b) => a.tick - b.tick);
+
+      // Determine default instrument (first program change or 0 for piano)
+      const defaultInstrument = programChanges.length > 0 ? programChanges[0].programNumber : 0;
+
+      parts[partName] = {
+        notes,
+        lyrics,
+        trackIndex,
+        programChanges,
+        defaultInstrument
+      };
+    });
+    
+    this.parsedData.parts = parts;
+  }
+
+  /**
+   * Convert a MIDI note number to note name
+   * @private
+   */
+  _midiNoteToName(noteNumber) {
+    const notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+    const octave = Math.floor(noteNumber / 12) - 1;
+    const note = notes[noteNumber % 12];
+    return `${note}${octave}`;
+  }
+
+  /**
+   * Convert bytes to number
+   * @private
+   */
+  _bytesToNumber(bytes) {
+    let value = 0;
+    for (let i = 0; i < bytes.length; i++) {
+      value = (value << 8) | bytes[i];
+    }
+    return value;
+  }
+
+  /**
+   * Convert bytes to string
+   * @private
+   */
+  _bytesToString(bytes) {
+    return new TextDecoder().decode(bytes);
+  }
+
+  /**
+   * Read variable-length value from MIDI data
+   * @private
+   */
+  _readVariableLengthValue(data, position) {
+    let value = 0;
+    let byte;
+    let bytesRead = 0;
+    
+    // noinspection JSBitwiseOperatorUsage
+    do {
+      byte = data[position + bytesRead++];
+      value = (value << 7) | (byte & 0x7F);
+    } while (byte & 0x80);
+    
+    return { value, bytesRead };
+  }
+
+  /**
+   * Convert ticks to time in seconds considering tempo changes within bars
+   * @private
+   */
+  _ticksToTime(targetTick, midi) {
+    const ticksPerBeat = midi.ticksPerBeat || 480;
+    
+    // Get all tempo events sorted by tick
+    const tempoEvents = [];
+    midi.tracks.forEach(track => {
+      track.events.forEach(event => {
+        if (event.type === 'tempo') {
+          tempoEvents.push(event);
+        }
+      });
+    });
+    tempoEvents.sort((a, b) => a.tick - b.tick);
+    
+    let totalTime = 0;
+    let currentTick = 0;
+    let currentTempo = 120; // Default tempo
+    
+    // Process tempo changes up to the target tick
+    for (const tempoEvent of tempoEvents) {
+      if (tempoEvent.tick > targetTick) break;
+      
+      // Add time for the segment from currentTick to this tempo change
+      if (tempoEvent.tick > currentTick) {
+        const segmentTicks = tempoEvent.tick - currentTick;
+        const segmentTime = (segmentTicks / ticksPerBeat) * (60 / currentTempo);
+        totalTime += segmentTime;
+        currentTick = tempoEvent.tick;
+      }
+      
+      // Update current tempo
+      currentTempo = tempoEvent.bpm;
+    }
+    
+    // Add time for remaining ticks at current tempo
+    if (targetTick > currentTick) {
+      const remainingTicks = targetTick - currentTick;
+      const remainingTime = (remainingTicks / ticksPerBeat) * (60 / currentTempo);
+      totalTime += remainingTime;
+    }
+    
+    return totalTime;
+  }
+}
+
+// Export the class
+export default MidiParser;
+
+// Example usage:
+// const parser = new MidiParser();
+// const fileInput = document.getElementById('midiFileInput');
+// 
+// fileInput.addEventListener('change', async (event) => {
+//   const file = event.target.files[0];
+//   const arrayBuffer = await file.arrayBuffer();
+//   
+//   try {
+//     const parsedData = await parser.parse(arrayBuffer);
+//     console.log('Parsed MIDI data:', parsedData);
+//     console.log('Parts:', parsedData.parts);
+//     console.log('Bar structure:', parsedData.barStructure);
+//     console.log('Metadata:', parsedData.metadata);
+//   } catch (error) {
+//     console.error('Error parsing MIDI file:', error);
+//   }
+// });