Note start and stop times generated for single-channel-per-track type 1 midi files

Author: Cornerback24

MidiData.py

@@ -1,6 +1,7 @@
 from MidiEventDecoder import MidiEventDecoder
 from TrackData import TrackData
 from TrackData import TempoChanges
+from MidiEvents import *
 
 #contains the finalized data after anylisis
 class MidiData:
@@ -21,57 +22,40 @@ def __init__(self, midiFilename):
 
         #maps running total of delta times to microsecondsPerQuarter
         tempoChanges = TempoChanges()
-        self.trackZeroEvents = []
         self.tracks = []
 
         deltaTimeTotal = 0
         self.msPerBeat = 500 #default 120 bpm
-        #should be a track header
-        event = self.eventDecoder.nextEvent()
-
-        #read in trackZeroEvents
-        while not(event.eventClass == "Meta"
-                and event.eventType == "EndOfTrack"):
-            event = self.eventDecoder.nextEvent()
-            deltaTimeTotal = deltaTimeTotal + event.deltaTime
-            self.trackZeroEvents.append(event)
-            if (event.eventClass == "Meta" and
-                event.eventType == "SetTempo"):
-                tempoChanges.addTempoChange(deltaTimeTotal, event)
-                
 
         #read in each track
         tracknum = 0 #used to create temporary track names
         while self.eventDecoder.hasMoreEvents():
-            tracknum = tracknum + 1
             trackName = "Track" + str(tracknum)
+            tracknum = tracknum + 1
             #should be a track header
-            event = self.eventDecoder.nextEvent()
             trackData = TrackData(trackName)
+            event = self.eventDecoder.nextEvent()
             #set up tempoChanges
             tempoChanges.reset()
+            self.msPerBeat = 500 #default 120 bpm
             deltaTimeTotal = 0
             nextTotal = 0
             msTotal = 0 #current time in ms
-            while (tempoChanges.hasMore() and
-                   tempoChanges.deltaTimeTotal() == 0):
-                self.msPerBeat = tempoChanges.usPerQuarter()*.001
-                tempoChanges.findNext()
             #add events
-            while not(event.eventClass == "Meta"
-                and event.eventType == "EndOfTrack"):
+            while not(isinstance(event, EndOfTrackEvent)):
                 event = self.eventDecoder.nextEvent()
+                if (isinstance(event, SetTempoEvent)):
+                    tempoChanges.addTempoChange(deltaTimeTotal, event.tempo)
                 nextTotal = deltaTimeTotal + event.deltaTime
                 #calcaute absolute start time for event in ms
                 if self.isTicksPerBeat:
                     while (tempoChanges.hasMore() and
-                           nextTotal > tempoChanges.deltaTimeTotal()):
+                           nextTotal >= tempoChanges.deltaTimeTotal()):
                         msTotal = msTotal + ((tempoChanges.deltaTimeTotal() -
                                      deltaTimeTotal)*self.msPerBeat/self.ticksPerBeat)
-                        deltaTimeTotal = (tempoChanges.deltaTimeTotal() -
-                                     deltaTimeTotal) + deltaTimeTotal
-                        tempoChanges.findNext()
+                        deltaTimeTotal = tempoChanges.deltaTimeTotal()
                         self.msPerBeat = tempoChanges.usPerQuarter()*.001
+                        tempoChanges.findNext()
                     msTotal = (msTotal +
                            ((nextTotal-deltaTimeTotal)*self.msPerBeat/self.ticksPerBeat))
                 else:
@@ -81,14 +65,8 @@ def __init__(self, midiFilename):
                 event.setStartTime(msTotal)
                 trackData.addEvent(event)
             self.tracks.append(trackData)
-#this line just for testing
-            ''''
-midiData = MidiData("testMidiFile.mid")
-for x in midiData.trackZeroEvents:
-    print(x)
-for y in midiData.tracks:
-    print("\n\n----------------------")
-    for x in y.events:
-        print(x)
-'''
-        
+
+    def getNumTracks(self):
+        return len(self.tracks)
+    def getTrack(self, index):
+        return self.tracks[index]

MidiEvents.py

@@ -10,18 +10,23 @@ def __init__(self):
         self.formatType = None
         self.numTracks = None
     def __str__(self):
-        s = ("Format type: " + str(self.formatType)
+        s = ("Header Chunck, Format type: " + str(self.formatType)
                 + " Number of tracks: " + str(self.numTracks))
         if self.ticksPerBeat != None:
-            s = s + "\nTicks per Beat: " + str(self.ticksPerBeat)
+            s = s + "\n\t Ticks per beat: " + str(self.ticksPerBeat)
+        if self.framesPerSecond != None:
+            s = s + "\n\t Frames per second: " + str(self.framesPerSecond)
+            s = s + "\n\t Ticks per frame: " + str(self.ticksPerFrame)
         return s
     def setFromBytes(self, headerDefByts, headerBodyBytes):
         self.formatType = int.from_bytes(headerBodyBytes[0:2], "big")
         self.numTracks = int.from_bytes(headerBodyBytes[2:4], "big")
         timeDivision = headerBodyBytes[4:6]
         if Util.msbIsOne(headerBodyBytes): #frames per second
             self.framesPerSecond = timeDivision[0] & int('7f', 16)
-            self.tickesPerFrame = int.from_bytes(timeDivision[1:2], "big")
+            if (self.framesPerSecond == 29):
+                self.framesPerSecond = 29.97
+            self.ticksPerFrame = int.from_bytes(timeDivision[1:2], "big")
         else: #ticks per beat
             self.ticksPerBeat = int.from_bytes(timeDivision, "big")
         return
@@ -173,7 +178,7 @@ def setFromBytes(self, midiData):
         if (frameRateIdentifier == 1):
             self.frameRate = 25
         if (frameRateIdentifier == 10):
-            self.frameRate = 30
+            self.frameRate = 29.97
             self.dropFrame = True
         if (frameRateIdentifier == 11):
             self.frameRate = 30
@@ -332,13 +337,13 @@ def setFromBytes(self, midiData):
         #(and thus completly ignoring the msb of every byte)
         self.bendAmount = Util.varLenVal(midiData[2:3] + midiData[1:2])
     #pitchValue relative to 8192; positive for increase, negative for decrease
-    def bendAmount(self):
+    def relativeBendAmount(self):
         return self.bendAmount - 8192
     def __str__(self):
         return (super().__str__() + ", eventType: Pitch Bend"
                 + ", Channel: " + str(self.channel)
                 + "\n\t Amout (relative to 8192): "
-                    + str(self.bendAmount()))
+                    + str(self.relativeBendAmount()))
 
 class EventDictionaries:
     #maps a meta event type to its class

Note.py

@@ -1,11 +1,11 @@
-class Note:    
-    def __init__(self, start, pitch, velocity, chan):
+class Note:
+    #start and end times are in ms
+    def __init__(self, start, pitch, velocity, channel):
         self.pitch = pitch #note number
-        self.chan = chan
+        self.channel = channel
         self.startTime = start
         self.endTime = None
         self.velocity = velocity
-        self.releaseVelocity = None
         return
     def setEndTime(self, endTime):
         self.endTime = endTime
@@ -19,4 +19,34 @@ def sortVal(self):
         return (self.startTime + 1)*1000 + self.pitch*.001
     def __lt__(self, other):
         return self.sortVal() < other.sortVal()
+    def __str__(self):
+        if self.pitch in Note.PITCH_DICTIONARY:
+            pitch = Note.PITCH_DICTIONARY[self.pitch]
+        else:
+            pitch = str(pitch)
+        return ("Note " + str(pitch) + " "
+                + str("{0:.2f}".format(round(self.startTime*.001, 2))) + "s to "
+                + str("{0:.2f}".format(round(self.endTime*.001, 2))) + "s"
+                + " Channel: " + str(self.channel))
+
+    #octaves may be relative 
+    PITCH_DICTIONARY = {0:"C-1",1:"C#-1",2:"D-1",3:"D#-1",4:"E-1",5:"F-1",6:"F#-1",
+            7:"G-1",8:"G#-1",9:"A-1",10:"A#-1",11:"B-1",12:"C0",13:"C#0",
+            14:"D0",15:"D#0",16:"E0",17:"F0",18:"F#0",19:"G0",
+            20:"G#0",21:"A0",22:"A#0",23:"B0",24:"C1",25:"C#1",26:"D1",
+            27:"D#1",28:"E1",29:"F1",30:"F#1",31:"G1",32:"G#1",33:"A1",34:"A#1",
+            35:"B1",36:"C2",37:"C#2",38:"D2",39:"D#2",40:"E2",41:"F2",
+            42:"F#2",43:"G2",44:"G#2",45:"A2",46:"A#2",47:"B2",48:"C3",
+            49:"C#3",50:"D3",51:"D#3",52:"E3",53:"F3",54:"F#3",55:"G3",
+            56:"G#3",57:"A3",58:"A#3",59:"B3",60:"C4",61:"C#4",62:"D4",
+            63:"D#4",64:"E4",65:"F4",66:"F#4",67:"G4",68:"G#4",69:"A4",
+            70:"A#4",71:"B4",72:"C5",73:"C#5",74:"D5",75:"D#5",76:"E5",
+            77:"F5",78:"F#5",79:"G5",80:"G#5",81:"A5",82:"A#5",83:"B5",
+            84:"C6",85:"C#6",86:"D6",87:"D#6",88:"E6",89:"F6",90:"F#6",
+            91:"G6",92:"G#6",93:"A6",94:"A#6",95:"B6",96:"C7",97:"C#7",
+            98:"D7",99:"D#7",100:"E7",101:"F7",102:"F#7",103:"G7",104:"G#7",
+            105:"A7",106:"A#7",107:"B7",108:"C8",109:"C#8",110:"D8",
+            111:"D#8",112:"E8",113:"F8",114:"F#8",115:"G8",116:"G#8",
+            117:"A8",118:"A#8",119:"B8",120:"C9",121:"C#9",122:"D9",
+            123:"D#9",124:"E9",125:"F9",126:"F#9",127:"G9"}
 

README.md

@@ -5,3 +5,15 @@ This will probably only work with type one midi files which are organized so tha
 
 (This isn't meant to create or manipulate midi files; it is just to get data from them.)
 Current work in progress is generating note objects from the midi file, with start and stop times.
+
+At this point, this script should be able to take a format one midi file that has one channel per track,
+and create Notes with start and stop times.  To do this, create a MidiData (ex midiData = MidiData("testMidiFile.mid")).  
+All the data should be initialized by the constructor.  The number of tracks created can be checked by calling midiData.getNumTracks().
+
+A TrackData can be retrieved by calling midiData.getTrack(index).  If trackData = midiData.getTrack(index) then
+trackData.notes is a list containing the notes for that track, sorted by start time.  Each Note has a startTime and endTime field, defined in 
+milliseconds (as well as a length() function that returns the length in milliseconds).  Each Note also has a pitch
+field in the range 0 - 127.  trackData.name contains the name of the track, which may be the name of the instrument on that track.  
+trackData.events contains the midi events in the track, and each event has a startTime field in milliseconds. Midi events are defined in
+MidiEvents.py.
+TrackData, MidiData, and Note may need to imported.

TrackData.py

@@ -1,49 +1,83 @@
 from Note import Note
+from MidiEvents import *
+import copy, bisect
 
 #contains data for a single track
 class TrackData:
     def __init__(self, name=""):
         self.notes = []
-        self.incompleteNotes = {} #maps pitches to notes without end times
+        #maps pitches to notes without end times
+        self.incompleteNotes = {}
         self.events = []
         self.name = name
+        self.deltaTimeTotal = 0
+        #if false, time division is frames per second
+        self.isTicksPerBeat = True
+        self.debug = False
         return
+    #Events need to be added in order, last event must be end of track
     def addEvent(self, event):
         self.events.append(event)
-        if (event.eventClass == "Meta" and
-            event.eventType == "Sequence/TrackName"):
-            self.name = event.text
-        if (event.eventClass == "Channel" and event.eventType == "NoteOn"):
-            self.incompleteNotes[event.noteNumber] = Note(event.startTime,
-                                                          event.noteNumber,
-                                                          event.velocity,
-                                                          event.channel)
-        if (event.eventClass == "Channel" and event.eventType == "NoteOff"):
-            self.incompleteNotes[event.noteNumber].setEndTime(event.startTime)
-            self.notes.append(self.incompleteNotes[event.noteNumber])
-            del self.incompleteNotes[event.noteNumber]
-        if (event.eventClass == "Meta" and event.eventType == "EndOfTrack"):
+        if (isinstance(event, TrackNameEvent)):
+            self.name = event.trackName
+        elif (isinstance(event, NoteOnEvent) and
+              not(event.isNoteOff())):
+            if event.noteNumber in self.incompleteNotes and self.debug:
+                print("Note on event for note " + str(event.noteNumber)
+                      + " already playing, skipping...")
+            else:
+                self.incompleteNotes[event.noteNumber] = Note(event.startTime,
+                                                              event.noteNumber,
+                                                              event.velocity,
+                                                              event.channel)
+        elif (isinstance(event, NoteOffEvent) or
+              (isinstance(event, NoteOnEvent) and event.isNoteOff())):
+            if event.noteNumber in self.incompleteNotes:
+                self.incompleteNotes[event.noteNumber].setEndTime(event.startTime)
+                self.notes.append(self.incompleteNotes[event.noteNumber])
+                del self.incompleteNotes[event.noteNumber]
+            elif self.debug:
+                print("Note off event for note " + str(event.noteNumber)
+                      + " not playing, skipping...")
+        elif (isinstance(event, EndOfTrackEvent)):
             self.notes.sort()
+    def setTempoChanges(self, tempoChanges):
+        self.tempoChanges = copy.deepcopy(tempoChanges)
+    def getTempoChanges(self, tempoChanges):
+        return copy.deepcopy(self.tempoChanges)
 
 #this is kind of like an ordered dictionary
 class TempoChanges:
     def __init__(self):
-        self.deltaTimeTotals = []
-        self.tempoChangeEvents = []
+        self.tempoChanges = []
         self.index = 0
         return
     #tempo changes need to be added in order
-    def addTempoChange(self, deltaTimeTotal, event):
-        self.deltaTimeTotals.append(deltaTimeTotal)
-        self.tempoChangeEvents.append(event)
+    #tempo in microseconds per quarter note
+    def addTempoChange(self, deltaTimeTotal, tempo):
+        #TODO change index?
+        bisect.insort(self.tempoChanges,
+                      TempoChange(deltaTimeTotal, tempo))
     #so that class can be used as a stream
     def deltaTimeTotal(self):
-        return self.deltaTimeTotals[self.index]
+        return self.tempoChanges[self.index].deltaTimeTotal
     def usPerQuarter(self):
-        return self.tempoChangeEvents[self.index].usPerQuarter
+        return self.tempoChanges[self.index].tempo
     def findNext(self):
         self.index = self.index + 1
+    #returns true if the current index is a tempo change
+    #(will return true if findNext will go beyond end of
+    # list, this is intentional)
     def hasMore(self):
-        return self.index + 1 < len(self.tempoChangeEvents)
+        return self.index < len(self.tempoChanges)
     def reset(self): #go back to first tempo change
         self.index = 0
+
+class TempoChange:
+    #deltaTimeTotal in ticks
+    #tempo in microseconds per quarter note
+    def __init__(self, deltaTimeTotal, tempo):
+        self.deltaTimeTotal = deltaTimeTotal
+        self.tempo = tempo
+    def __lt__(self, other):
+        return self.deltaTimeTotal < other.deltaTimeTotal