comparison Syncopation models/synpy/readmidi.py @ 45:6e9154fc58df

moving the code files to the synpy package directory

+# -*- coding: utf-8 -*-
+"""
+Created on Sat Mar 21 22:19:52 2015
+
+@author: christopherh
+"""
+
+from midiparser import MidiFile, MidiTrack, DeltaTime, MidiEvent
+#from RhythmParser import Bar
+
+from music_objects import *
+from basic_functions import *
+
+
+
+
+def read_midi_file(filename):
+	""" open and read a MIDI file, return a MidiFile object """
+
+	#create a midifile object, open and read a midi file
+	midiFile = MidiFile()
+	midiFile.open(filename, 'rb')
+	midiFile.read()
+	midiFile.close()
+
+	return midiFile
+
+# def get_bars(midiFile, trackindex=1):
+# 	""" returns a list of bar objects from a MidiFile object """
+
+# 	# select a track to extract (default = 1, ignoring dummy track 0)
+# 	track = midiFile.tracks[trackindex] 
+# 	eventIndex = 0
+# 	numNotes = 0
+
+# 	noteonlist = []
+# 	noteOnFound==True
+
+# 	while noteOnFound==True:
+# 		(noteOnIndex, noteOnDelta, noteOnFound) = self.find_event(track, eventIndex, lambda e: e.type == 'NOTE_ON')
+# 		noteEvent = track.events[noteOnIndex]
+# 		eventIndex = noteOnIndex + 1
+            	
+
+#find_event(x.tracks[0], 0, lambda e: (e.type == 'NOTE_ON') | (e.type == 'KEY_SIGNATURE') | (e.type == "TIME_SIGNATURE"))
+
+'''
+	#read midiFile
+	
+	
+
+	run through selected track getting notes out to build bars
+
+'''
+	
+
+
+def get_bars_from_midi(midiFile):
+
+	# couple of inner functions to tidy up getting the initial values of
+	# tempo and time signature
+	def get_initial_tempo(timeList):
+
+		tempo = None
+		i=0
+		# Find the initial time and tempo:
+		while(tempo == None and i<len(timeList)):
+			event = timeList[i]
+			i = i + 1
+			if event.type=="SET_TEMPO":
+		 		if tempo==None:
+					tempo = midi_event_to_qpm_tempo(event)
+
+		if tempo==None:
+			tempo = 120
+
+		return tempo
+
+	def get_initial_time_signature(timeList):
+
+		timesig = None
+		i=0
+		# Find the initial time and tempo:
+		while(timesig == None and i<len(timeList)):
+			event = timeList[i]
+			i = i + 1
+			if event.type=="TIME_SIGNATURE":
+				if timesig==None:
+					timesig = midi_event_to_time_signature(event)
+
+		if timesig==None:
+			timesig = TimeSignature("4/4")
+			
+		return timesig
+
+
+	def get_time_signature(timeList,barStartTime, barEndTime, currentTimeSignature = None):
+		
+		timesig = None
+		i=0
+		
+		while(i<len(timeList)):
+			# run through list until we find the most recent time signature
+			# before the end of the current bar
+			event = timeList[i]
+			i = i + 1
+			if event.time>=barEndTime:
+				break
+
+			if event.type=="TIME_SIGNATURE" and event.time>=barStartTime:
+				timesig = midi_event_to_time_signature(event)
+				event.type = "USED_TIME_SIGNATURE"
+	
+		if timesig==None:
+			if currentTimeSignature==None:
+				timesig = TimeSignature("4/4")
+			else:
+				timesig = currentTimeSignature
+
+		return timesig	
+
+	def get_tempo(timeList,barStartTime, barEndTime, currentTempo = None):
+		
+		tempo = None
+		i=0
+		# get first event:
+		while(i<len(timeList)):
+			# run through list until we find the most recent time signature
+			# before the end of the current bar
+			event = timeList[i]
+			i = i + 1
+			if event.time>=barEndTime:
+				break
+
+			# run through list until we find the most recent tempo
+			# before the end of the current bar
+			if event.type=="SET_TEMPO" and event.time>=barStartTime:
+				tempo = midi_event_to_qpm_tempo(event)
+				event.type = "USED_TEMPO"
+
+		if tempo==None:
+			if currentTempo==None:
+				tempo = 120
+			else:
+				tempo = currentTempo
+
+		return tempo
+
+
+
+	# get initial time sig and tempo or use defaults
+	timeList = get_time_events(midiFile)
+
+	# get notes from the midi file (absolute start times from start of file)
+	notesList = get_notes_from_event_list(get_note_events(midiFile))
+	
+
+	# get initial tempo and time signature from time list
+	timesig = get_initial_time_signature(timeList)
+	tempo = get_initial_tempo(timeList)
+
+
+
+
+	# ticks per quarter note:
+	ticksPerQuarter = midiFile.ticksPerQuarterNote
+	#calculate the initial length of a bar in ticks
+	barlength = calculate_bar_ticks(timesig.get_numerator(), timesig.get_denominator(), ticksPerQuarter)
+	# initialise time for start and end of current bar
+	barStartTime = 0
+	barEndTime = barlength
+	
+
+	# initialise bars list
+	bars = BarList()
+	noteIndex = 0
+
+	note = notesList[0]
+	# run through the notes list, chopping it into bars
+	while noteIndex<len(notesList):
+		#create a local note sequence to build a bar
+		currentNotes = NoteSequence()
+
+		timesig = get_time_signature(timeList,barStartTime, barEndTime, timesig)
+		tempo = get_tempo(timeList,barStartTime, barEndTime, tempo)
+		
+
+		#find all the notes in the current bar
+		while(note.startTime<barEndTime):
+			#make note start time relative to current bar
+			note.startTime = note.startTime - barStartTime
+			#add note to current bar note sequence
+			currentNotes.append(note)
+			noteIndex = noteIndex + 1
+			if noteIndex<len(notesList):
+				note = notesList[noteIndex]
+			else:
+				break
+
+		# create a new bar from the current notes and add it to the list of bars
+		bars.append(Bar(currentNotes, timesig, ticksPerQuarter, tempo))
+
+		barStartTime = barEndTime
+
+		barEndTime = barEndTime + barlength
+
+	return bars
+
+		
+#get note objects from a list of note midi events
+def get_notes_from_event_list(noteEventList):
+	noteslist = NoteSequence()
+
+	index = 0
+	
+	#while not at the end of the list of note events
+	while index<len(noteEventList):
+		#get next event from list
+		event = noteEventList[index]
+		index = index + 1
+		#if we've found the start of a note, search for the corresponding end event
+		if event.type=="NOTE_ON" and event.velocity!=0:
+			localindex = index
+			
+			#find corresponding end event
+			while localindex<len(noteEventList):
+				endEvent = noteEventList[localindex]
+				#if its the same note and it's an end event
+				if endEvent.pitch==event.pitch and (endEvent.type=="NOTE_OFF" or (endEvent.type=="NOTE_ON" and endEvent.velocity==0)):
+					#make a note
+					note = Note(event.time,endEvent.time-event.time,event.velocity)
+					#alter the type of this end event so it can't be linked to another note on
+					endEvent.type = "DUMMY"
+					#add the note to the list
+					noteslist.append(note)
+					#found the end of the note so break out of the local loop
+					break
+
+	return noteslist
+
+
+
+
+
+
+
+
+
+
+def get_note_events(midiFile, trackNumber = None):
+	"""
+	Gets all note on and note off events from a midifile.
+
+	If trackNumber is not specified, the function will check the file format
+	and pick either track 0 for a type 0 (single track format) or track 1 
+	for a type 1 or 2 (multi-track) midi file.
+
+	"""
+
+	if trackNumber==None:
+		if midiFile.format==0:
+			trackNumber=0
+		else:
+			trackNumber=1
+
+	return get_events_of_type(midiFile, trackNumber, lambda e: (e.type == 'NOTE_ON') | (e.type == "NOTE_OFF") )
+	
+
+
+def get_time_events(midiFile):
+	"""
+	Gets time signature and tempo events from a MIDI file (MIDI format 0 
+	or format 1) and returns a list of those events and their associated 
+	absolute start times.  If no time signature or tempo are specified then
+	defaults of 4/4 and 120QPM are assumed.
+
+	From the MIDI file specification:
+
+	"All MIDI Files should specify tempo and time signature. If they don't, 
+	the time signature is assumed to be 4/4, and the tempo 120 beats per 
+	minute. In format 0, these meta-events should occur at least at the 
+	beginning of the single multi-channel track. In format 1, these meta-events
+	should be contained in the first track. In format 2, each of the temporally
+	independent patterns should contain at least initial time signature and 
+	tempo information."
+
+	"""
+	return get_events_of_type(midiFile, 0, lambda e: (e.type == 'SET_TEMPO') | (e.type == "TIME_SIGNATURE") )
+	
+
+def get_events_of_type(midiFile, trackIndex, lambdaEventType):
+	"""
+	Filters the events in a midi track that are selected by the 
+	function object lambdaEventType e.g. lambda e: (e.type == 'NOTE_ON')
+	Return a list containing the relevant events with appropriate 
+	delta times between them 
+	"""
+	
+	track = midiFile.tracks[trackIndex] 
+	eventIndex = 0
+	#	numTimeEvents = 0
+
+	localEventList  = []
+	localEventFound = True
+	#accumulatedTime = 0
+
+	while localEventFound==True:
+		#find the next time event from the track:
+		(localEventIndex, localEventDelta, localEventFound) = find_event(track, eventIndex, lambdaEventType)
+
+		if localEventFound==True:
+			#get the time event object out of the track
+			localEvent = track.events[localEventIndex]
+
+			#update the start event to search from
+			eventIndex = localEventIndex + 1
+
+			#calculate the absolute start time of the time event
+			#accumulatedTime = accumulatedTime + localEventDelta
+
+			localEventList.append(localEvent)
+
+	return localEventList
+
+
+def midi_event_to_time_signature(midiTimeSignatureEvent):
+	"""
+	Extract the numerator and denominator from a midi time signature
+	event and return a TimeSignature music object.  Ignore clocks per
+	quarternote and  32nds per quarternote elements since these are
+	only for sequencer metronome settings which we won't use here.
+	"""
+	if midiTimeSignatureEvent.type!="TIME_SIGNATURE":
+		print "Error in midi_event_to_time_signature(),  event must be a midi time signature type"
+		return None
+	else:
+		num = ord(midiTimeSignatureEvent.data[0])
+		denom = 2**ord(midiTimeSignatureEvent.data[1])
+		return TimeSignature("%d/%d" % (num, denom))
+	
+
+def midi_event_to_qpm_tempo(midiTempoEvent):
+	"""
+	Extract the tempo in QPM from a midi SET_TEMPO event
+	"""
+	if midiTempoEvent.type!="SET_TEMPO":
+		print "Error in midi_event_to_qpm_tempo(),  event must be a midi tempo event"
+		return None
+	else:
+		# tempo is stored as microseconds per quarter note
+		# in three bytes which we can extract as three ints:
+		values = map(ord, midiTempoEvent.data)
+		# first byte multiplied by 2^16, second 2^8 and third is normal units
+		# giving microseconds per quarter
+		microsecondsPerQuarter = values[0]*2**16 + values[1]*2**8 + values[2]
+
+		# to calculate QPM, 1 minute = 60million microseconds
+		# so divide 60million by micros per quarter:
+		return 60000000/microsecondsPerQuarter
+
+def find_event(track, eventStartIndex, lambdaExpr):
+	'''
+	From code by Csaba Sulyok:
+	Finds MIDI event based on lambda expression, starting from a given index.
+	Returns a tuple of the following 3 elements:
+	1. event index where the lambda expression is true
+	2. aggregate delta time from event start index until the found event
+	3. flag whether or not any value was found, or we've reached the end of the event queue
+	'''
+
+	eventIndex = eventStartIndex
+	deltaTime = 0
+	while eventIndex < len(track.events) and not lambdaExpr(track.events[eventIndex]):
+	    if track.events[eventIndex].type == 'DeltaTime':
+	        deltaTime += track.events[eventIndex].time
+	    eventIndex += 1
+
+	success = eventIndex < len(track.events)
+	return (eventIndex, deltaTime, success)
+
+