MidiEventDecoder uses classes per meta event

Author: Cornerback24

MidiEventDecoder.py

@@ -35,7 +35,15 @@ def midiEvent(self, midiData):
         midiData = tempData[temp:]
         #Meta Event
         if midiData[0:1] == b'\xff':
-            return MetaEvent(Util.varLenVal(deltaTime), midiData)
+            if midiData[1] in EventDictionaries.META_EVENT_DICTIONARY:
+                metaEventClass = EventDictionaries.META_EVENT_DICTIONARY[midiData[1]]
+            else:
+                metaEventClass = MetaEvent
+            metaEvent = metaEventClass()
+            metaEvent.setDeltaTimeFromBytes(deltaTime)
+            metaEvent.setFromBytes(midiData)
+            return metaEvent
+            #return MetaEvent(Util.varLenVal(deltaTime), midiData)
         #System Event
         if midiData[0:1] == b'\xf0' or midiData[0:1] == b'\xf7':
                 return SystemEvemt(Util.varLenVal(deltaTime), midiData)

MidiEvents.py

@@ -36,16 +36,7 @@ def __str__(self):
         return "Track Header " + str(self.midiData)
 
 class MidiEvent:
-    #data contained:
-    #eventType
-    #   chunkID
-    #   (midi): Note off, Note on, Note aftertouch, Controller, Program Change
-    #   Channel Aftertouch, Pitch Bend
-    #   meta
-    #   sysEx
-    def __init__(self, deltaTime):
-        self.deltaTime = deltaTime
-    #set the delta time from the bytes representing delta time
+    #set the delta time in clock ticks from the bytes representing delta time
     def setDeltaTimeFromBytes(self, deltaTimeBytes):
         self.deltaTime = Util.varLenVal(deltaTimeBytes)
     #sets the event data from the bytes (bytes should not include delta time)
@@ -60,104 +51,95 @@ def setStartTime(self, startTime): #set start time in ms
 
 ######################### Meta Event ################################################
 class MetaEvent(MidiEvent):
-    #delaTime in clock ticks
-    def __init__(self, deltaTime, midiData):
-        super().__init__(deltaTime)
-        self.eventClass = "Meta"
-        self.midiData = midiData
-        self.startTime = None
-        self.eventType = None
-        self.text = None
-        self.dataLength = midiData[2:3]
-        i = 2
-        while Util.msbIsOne(midiData[i:i+1]):
-            self.dataLength = self.dataLength + midiData[i+1:i+2]
-            i = i+1
-        i = i+1
-        self.data = midiData[i:]
-        #coverts bytes to a string
-        self.data = str(self.data)[2:len(str(self.data))-1]
-        if midiData[1] in Util.MetaEventDict:
-            self.eventType = Util.MetaEventDict[midiData[1]]
-        if self.eventType == "SequenceNumber":
-            self.sequenceNumber = Util.intFromBytes(midiData[3:])
-        if self.eventType == "SetTempo":
-            #micro seconds per quarter note
-            self.usPerQuarter = Util.intFromBytes(midiData[3:])
-        if self.eventType == "Sequence/TrackName" or self.eventType == "DeviceName":
-            self.text = midiData[3:].decode()
-    def setFromBytes(self, midiDataBytes):
+    def setFromBytes(self, midiData):
         print("Set bytes called on parent event class!")
     def __str__(self):
-        s = ("Meta " + str(self.midiData) + " deltaTime: "
-                + str(self.deltaTime) + " eventType: " + self.eventType)
-        if self.eventType == "SetTempo":
-            s = s + "\n\t usPerQuarter: " + str(self.usPerQuarter)
-        if self.eventType == "Sequence/TrackName":
-            s = s + "\n\t Sequence/TrackName: " + self.text
-        if self.eventType == "DeviceName":
-            s = s + "\n\t Device Name: " + self.text
-        return s
+        return "Meta  deltaTime: " + str(self.deltaTime)
 
 class SequenceNumberEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.sequenceNumber = int.from_bytes(midiData[3:], "big")
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.sequenceNumber = int.from_bytes(eventData, "big")
     def __str__(self):
         return (super().__str__() + " eventType: Sequence Number" +
             "\n\t Sequence Number: " + str(self.sequenceNumber))
 
 class TextEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.text = midiData[3:].decode()
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.text = eventData.decode()
     def __str__(self):
         return (super().__str__() + " eventType: Text" +
             "\n\t Text: " + str(self.text))
 
 class CopyrightNoticeEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.copyrightNotice = midiData[3:].decode()
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.copyrightNotice = eventData.decode()
     def __str__(self):
         return (super().__str__() + " eventType: Copyright Notice" +
                 "\n\t Copyright Notice: " + str(self.copyrightNotice))
 
-class TrackNameEevent(MetaEvent):
+class TrackNameEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.trackName = midiData[3:].decode()
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.trackName = eventData.decode()
     def __str__(self):
         return (super().__str__() + " eventType: Sequence/Track Name" +
             "\n\t Track Name: " + str(self.trackName))
 
 class InstrumentNameEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.instrumentName = midiData[3:].decode()
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.instrumentName = eventData.decode()
     def __str__(self):
         return (super().__str__() + " eventType: Instrument Name" +
             "\n\t Instrument Name: " + str(self.instrumentName))
 
 class LyricsEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.lyrics = midiData[3:].decode()
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.lyrics = eventData.decode()
     def __str__(self):
         return (super().__str__() + " eventType: Lyrics" +
                 "\n\t Lyrics: " + str(self.lyrics))
 
 class MarkerEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.marker = midiData[3:].decode()
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.marker = eventData.decode()
     def __str__(self):
         return (super().__str__() + " eventType:Marker" +
                 "\n\t Marker: " + str(self.marker))
 
 class CuePointEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.cuePoint = midiData[3:].decode()
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.cuePoint = eventData.decode()
     def __str__(self):
         return (super().__str__() + " eventType: Cue Point" +
                 "\n\t Cue Point: " + str(self.cuePoint))
+    
+class ProgramNameEvent(MetaEvent):
+    def setFromBytes(self, midiData):
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.programName = eventData.decode()
+    def __str__(self):
+        return (super().__str__() + " eventType: Program Name" +
+                "\n\t Program Name: " + str(self.programName))
+
+class DeviceNameEvent(MetaEvent):
+    def setFromBytes(self, midiData):
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.deviceName = eventData.decode()
+    def __str__(self):
+        return (super().__str__() + " eventType: Device Name" +
+                "\n\t Device Name: " + str(self.deviceName))
 
 class MidiChannelPrefixEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        self.channel = Util.intFromBytes(midiData[3:])
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.channel = Util.intFromBytes(eventData)
     def __str__(self):
         return (super().__str__() + " eventType: Midi Channel Prefix"
                 + "\n\t Channel: " + str(self.channel))
@@ -172,15 +154,17 @@ def __str__(self):
 class SetTempoEvent(MetaEvent):
     def setFromBytes(self, midiData):
         #tempo is in microseconds per quarter note
-        self.tempo = Util.intFromBytes(midiData[3:])
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        self.tempo = Util.intFromBytes(eventData)
     def __str__(self):
         return (super().__str__() + " eventType: Set Tempo"
                 + "\n\t Tempo (microseconds per quarter note): "
                     + str(self.tempo))
 
 class SMPTEOffsetEvent(MetaEvent):
     def setFromBytes(self, midiData):
-        frameRateIdentifier = Util.intFromBytes(midiData[3:4] & int('e0',16)) / 64
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
+        frameRateIdentifier = (eventData[0] & int('e0',16)) / 64
         #frame rate in fps
         self.frameRate = None
         self.dropFrame = False
@@ -193,60 +177,62 @@ def setFromBytes(self, midiData):
             self.dropFrame = True
         if (frameRateIdentifier == 11):
             self.frameRate = 30
-        self.hour = Util.intFromBytes(midiData[3:4] & int('1f', 16))
-        self.minute = Util.intFromBytes(midiData[4:5])
-        self.second = Util.intFromBytes(midiData[5:6])
-        self.frame = Util.intFromBytes(midiData[6:7] )
+        self.hour = eventData[0] & int('1f', 16)
+        self.minute = Util.intFromBytes(eventData[1:2])
+        self.second = Util.intFromBytes(eventData[2:3])
+        self.frame = Util.intFromBytes(eventData[3:4] )
         #always 100 sub-frames per frame
-        self.subFrame = Util.intFromBytes(midiData[7:])
+        self.subFrame = Util.intFromBytes(eventData[4:])
     def __str__(self):
         return (super().__str__() + " eventType: SMPTE Offset"
                 + "\n\t Frame Rate: " + str(self.frameRate)
-                + "Drop Frame: " + str(self.dropFrame)
+                + " Drop Frame: " + str(self.dropFrame)
                 + "\n\t Hour: " + str(self.hour)
-                + "Minute: " + str(self.minute)
+                + " Minute: " + str(self.minute)
                 + "\n\t Frame: " + str(self.frame)
-                + "Sub-Frame: " + str(self.subFrame))
+                + " Sub-Frame: " + str(self.subFrame))
 
 class TimeSignatureEvent(MetaEvent):
     def setFromBytes(self, midiData):
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
         #default is 4
-        self.numerator = Util.intFromBytes(midiData[3:4])
+        self.numerator = Util.intFromBytes(eventData[0:1])
         #default is 4 (or encoded 2 since 2^2 is 4)
-        self.denominator = math.pow(2, Util.intFromBytes(midiData[4:5]))
+        self.denominator = math.pow(2, Util.intFromBytes(eventData[1:2]))
         #default is 1 (or 24 encoded since 24/24 = 1)
-        self.beatsPerTick = Util.intFromBytes(midiData[5:6]) / 24
+        self.beatsPerTick = Util.intFromBytes(eventData[2:3]) / 24
         #default is 8
-        self.thirtySecondNotesPerBeat = Util.intFromBytes(midiData[6:])
+        self.thirtySecondNotesPerBeat = Util.intFromBytes(eventData[3:])
     def __str__(self):
         return (super().__str__() + " eventType: Time Signature"
                 + "\n\t Time Signature: " + str(self.numerator)
                     + "/" + str(self.denominator)
-                + "\n\t Beats per tick: " + str(self.hour)
-                + "32nd notes per beat: " + str(self.thirtySecondNotesPerBeat))
+                + "\n\t Beats per tick: " + str(self.beatsPerTick)
+                + " 32nd notes per beat: " + str(self.thirtySecondNotesPerBeat))
 
 class KeySignatureEvent(MetaEvent):
     def setFromBytes(self, midiData):
+        eventData = Util.stripLeadingVariableLength(midiData[2:])
         #True for major, False for minor
-        self.majorKey = (Util.intFromBytes(midiData[4:5]) == 0)
+        self.majorKey = (Util.intFromBytes(eventData[1:2]) == 0)
         #true for sharps, false for flats
-        self.sharpKey = (Util.intFromBytes(midiData[3:4]) > 0)
-        self.numberOfAccidentals = abs(Util.intFromBytes(midiData[3:4]))
+        self.sharpKey = (Util.intFromBytes(eventData[0:1], True) > 0)
+        self.numberOfAccidentals = abs(Util.intFromBytes(eventData[0:1], True))
     def __str__(self):
         sharpsOrFlats = "sharps" if self.sharpKey else "flats"
         majorOrMinor = ""
         if (self.numberOfAccidentals > 0):
            majorOrMinor = ", major" if self.majorKey else ", minor" 
         return (super().__str__() + " eventType: Key Signature"
                 + "\n\t Number of " + str(sharpsOrFlats) + ": "
-                    + "/" + str(self.numberOfAccidentals) + majorOrMinor)
+                    + str(self.numberOfAccidentals) + majorOrMinor)
 
 class SequencerSpecificEvent():
     def setFromBytes(self, midiData):
-        self.data = midiData
+        self.eventData = Util.stripLeadingVariableLength(midiData[2:])
     def __str__(self):
         return (super().__str__() + " eventType: Sequencer Specific"
-                + "\n\t Raw data " + str(self.data))
+                + "\n\t Raw data (without variable-length)" + str(self.eventData))
 
 
 ############################ System Event #########################################
@@ -265,7 +251,7 @@ def __str__(self):
 ######################### Channel Event ############################################
 class ChannelEvent(MidiEvent):
     def __init__(self, deltaTime, midiData):
-        super().__init__(deltaTime)
+        self.deltaTime = deltaTime
         self.midiData = midiData
         self.eventClass = "Channel"
         self.startTime = None
@@ -328,3 +314,23 @@ def __str__(self):
 
     #class variable used for running status
     prevEventData = ()
+
+class EventDictionaries:
+    #maps a meta event type to its class
+    META_EVENT_DICTIONARY = MetaEventDict = {0 : SequenceNumberEvent,
+                                             1 : TextEvent,
+                                             2 : CopyrightNoticeEvent,
+                                             3 : TrackNameEvent,
+                                             4 : InstrumentNameEvent,
+                                             5 : LyricsEvent,
+                                             6 : MarkerEvent,
+                                             7 : CuePointEvent,
+                                             8 : ProgramNameEvent,
+                                             9 : DeviceNameEvent,
+                                             32 : MidiChannelPrefixEvent,
+                                             47 : EndOfTrackEvent,
+                                             81 : SetTempoEvent,
+                                             84 : SMPTEOffsetEvent,
+                                             88 : TimeSignatureEvent,
+                                             89 : KeySignatureEvent,
+                                             127: SequencerSpecificEvent}

Util.py

@@ -21,6 +21,8 @@ def lshiftByteArray(sourceByteArray, numBits):
 
     #takes a bytes object formatted in variable length and
     #returns the int value represented
+    #does not check if the variable length value is valid, as
+    #it ignores the msb of every byte
     @staticmethod
     def varLenVal(varLenBytes):
         if len(varLenBytes) == 0:
@@ -33,15 +35,27 @@ def varLenVal(varLenBytes):
             returnValBytes = Util.lshiftByteArray(returnValBytes, 7)
             returnValBytes[len(returnValBytes)-1] = (
                 returnValBytes[len(returnValBytes)-1] | nextByte)
-        return int.from_bytes(returnValBytes, "big")
+        return int.from_bytes(returnValBytes, "big")        
 
     @staticmethod
     def msbIsOne(byte): #returns true if the msb of a bytes object is 1
         return (byte[0] & int('80',16)) > 0
 
+    #strips a variable length quanity off of a byte array
+    #and returns the rest
     @staticmethod
-    def intFromBytes(byteArray):
-        return int.from_bytes(byteArray, "big")
+    def stripLeadingVariableLength(byteArray):
+        varLenEndIndex = 0
+        while (varLenEndIndex < len(byteArray) and
+               Util.msbIsOne(byteArray[varLenEndIndex:varLenEndIndex + 1])):
+                    varLenEndIndex = varnLenEndIndex + 1
+        #the last byte of a variable length value has msb 0
+        varLenEndIndex = varLenEndIndex + 1
+        return byteArray[varLenEndIndex:]
+
+    @staticmethod
+    def intFromBytes(byteArray, signed = False):
+        return int.from_bytes(byteArray, "big", signed = signed)
 
     #maps [byte with event type and channel] & b'\xf0' to event type
     ChannelEventDict = {int('80', 16) : "NoteOff",
@@ -51,19 +65,3 @@ def intFromBytes(byteArray):
                         int('c0', 16) : "ProgramChange",
                         int('d0', 16) : "ChannelAftertouch",
                         int('e0', 16) : "PitchBend"}
-    MetaEventDict = {0 : "SequenceNumber",
-                     1 : "TextEvent",
-                     2 : "CopyrightNotice",
-                     3 : "Sequence/TrackName",
-                     4 : "InstrumentName",
-                     5 : "Lyrics",
-                     6 : "Marker",
-                     7 : "CuePoint",
-                     9 : "DeviceName",
-                     32 : "MidiChannelPrefix",
-                     47 : "EndOfTrack",
-                     81 : "SetTempo",
-                     84 : "SMPTEOffset",
-                     88 : "TimeSignature",
-                     89 : "KeySignature",
-                     127: "SequencerSpecific"}