def mat2midi(mat, name, SampleRate): from midiutil.MidiFile import MIDIFile #incase import numpy as np [a, b] = mat.shape tStart = [0] out_midi = MIDIFile(1) track = 0 time = 0 tempo = 120 out_midi.addTrackName(track, time, "output track") out_midi.addTempo(track, time, tempo) nTrack = 1 for i in range(0, a): ind = [x for x in range(0, b - 2) if mat[i][x] != 0] while len(ind) > nTrack: out_midi.addTrackName(nTtrack, time, "output track") out_midi.addTempo(nTrack, time, tempo) nTrack = nTrack + 1 dur = (mat[i][-2]) / SampleRate for k in range(0, len(ind)): pit = ind[k] channel = int(mat[i][-1]) vol = int(mat[i][ind[k]]) out_midi.addNote(k, channel, pit, tStart[-1], dur, vol) tStart.append(tStart[-1] + dur) filename = "../output/" + name + ".mid" with open(filename, 'wb') as file: out_midi.writeFile(file) return (out_midi)
def export(self, filename): 'Exports the project to a MIDI-file' # entries must contain stuff if len(self.entries) == 0: return # reset the midi variable global Midi Midi = MIDIFile(1) Midi.addTrackName(track, time_start, 'MIDI Cuer') # the great export loop all_beats = int( math.ceil( self.entries[len(self.entries)-1][3] ) ) out = {} for x in xrange(1, len(self.entries)): out.update( self.calcIterBeats( self.entries[x-1][3], self.entries[x][3], self.entries[x-1][2], self.entries[x][2], self.stepsize ) ) for x in sorted(out.iterkeys()): AddTempo(x, out[x]) if self.BeatExists(x): AddNote(x) # de-comment following 3 lines for debugging during output # print 'Debuggin:' # for x in sorted(out): # print x, out[x] SaveIt(filename)
def make_song_file(mood,key,syllables): # create the MIDIFile object with 1 track MyMIDI = MIDIFile(1) if (mood == 'mood1'): mood = pass1 elif (mood == 'mood2'): mood = happy1 elif (mood == 'mood3'): mood = cool1 # tracks are numbered from zero. times are measured in beats. track = 0 time = 0 # add track name and tempo. MyMIDI.addTrackName(track,time,"Sample Track") MyMIDI.addTempo(track,time,100) key = key%12 MyMIDI = add_chords(MyMIDI,mood,key) MyMIDI = add_notes(MyMIDI,syllables,key,mood) # and write it to disk. binfile = open("song.mid", 'wb') MyMIDI.writeFile(binfile) binfile.close()
def midFile(melody): MyMIDI = MIDIFile(1) track = 0 time = 0 MyMIDI.addTrackName(track, time, "Vireo") MyMIDI.addTempo(track, time, 340) track = 0 channel = 0 time = 0 volume = 100 for i in melody: data = i.split() MyMIDI.addNote(track, channel, int(data[0].strip()), time, int(data[1].strip()), volume) time = time + int(data[1].strip()) midi = "" binfile = open("./static/test.mid", "wb") MyMIDI.writeFile(binfile) binfile.close() binfile = open("./static/test.mid", "rb") midi = binfile.read() binfile.close() return midi
def MIDI_VV(mf, noteLengths1_VV, noteLengths2_VV, noteLengths3_VV, currentNote1_VV, currentNote2_VV, currentNote3_VV): if mf is None: mf = MIDIFile(3) #3 tracks startTime = 0 #begint bij het begin track = 0 mf.addTrackName(track, startTime, "5/4 Beat") mf.addTempo(track, startTime, BPM) return MIDI_VV(mf, noteLengths1_VV, noteLengths2_VV, noteLengths3_VV, currentNote1_VV, currentNote2_VV, currentNote3_VV) if len(noteLengths1_VV) == 0: print("...") else: track = 0 #eerste track channel = 10 #percussie volume = 100 instrument = 35 #kick time = currentNote1_VV #startpunt noot duration = noteLengths1_VV.pop(0) #1e nootlengte uit de lijst mf.addNote(track, channel, instrument, time, duration, volume) #voeg noot toe aan midifile currentNote1_VV += duration return MIDI_VV(mf, noteLengths1_VV, noteLengths2_VV, noteLengths3_VV, currentNote1_VV, currentNote2_VV, currentNote3_VV) if len(noteLengths2_VV) == 0: print("...") else: track = 0 #tweede track (voor losse tracks gebruik 1) startTime = 0 channel = 10 #percussie volume = 100 instrument = 38 #snare time = currentNote2_VV #startpunt noot duration = noteLengths2_VV.pop(0) #1e nootlengte uit de lijst mf.addNote(track, channel, instrument, time, duration, volume) currentNote2_VV += duration return MIDI_VV(mf, noteLengths1_VV, noteLengths2_VV, noteLengths3_VV, currentNote1_VV, currentNote2_VV, currentNote3_VV) if len(noteLengths3_VV) == 0: print("Done") output_file = input("Name MIDI-file: ") #write to disk with open("output.mid", 'wb') as output_file: mf.writeFile(output_file) else: track = 0 #derde track (voor losse tracks gebruk 2) startTime = 0 channel = 10 #percussie volume = 100 instrument = 42 #hihat time = currentNote3_VV #startpunt noot duration = noteLengths3_VV.pop(0) #1e nootlengte uit de lijst mf.addNote(track, channel, instrument, time, duration, volume) currentNote3_VV += duration return MIDI_VV(mf, noteLengths1_VV, noteLengths2_VV, noteLengths3_VV, currentNote1_VV, currentNote2_VV, currentNote3_VV)
def pixels_to_midi2(): pix = get_image_data("small.jpg") mf = MIDIFile(1) track = 0 time = 0 channel = 0 volume = 100 mf.addTrackName(track, time, "Sample") mf.addTempo(track, time, 1000) for i in xrange(len(pix)): if i >= len(pix) - 4: break p1 = rgb_to_midi(pix[i]) p2 = rgb_to_midi(pix[i + 1]) p3 = rgb_to_midi(pix[i + 2]) duration = 1 if time % 4 == 0: mf.addNote(track, channel, p1, time, 4, 120) mf.addNote(track, channel, p2, time, 4, 120) mf.addNote(track, channel, p3, time, 4, 120) else: mf.addNote(track, channel, p1, time, duration, 50) time += 1 with open("small.mid", 'wb') as outf: mf.writeFile(outf)
def play(request): global outputId json = simplejson.loads(request.POST.get('notes')) midiFile = MIDIFile(1) track = 0 time = 0 midiFile.addTrackName(track, time, "Sample Track") midiFile.addTempo(track, time, 120) channel = 0 volume = 100 string = "" for note in json['notes']: pitch = strToMidiPitch(note['pitch']) duration = note['duration'] start = note['start'] midiFile.addNote(track, channel, pitch, start, duration, volume) string += "added note " + note['pitch'] + ": " + str(pitch) + ", " binfile = open("/tmp/output.mid", 'wb') midiFile.writeFile(binfile) binfile.close() call(['fluidsynth', '-l', '-F', '/tmp/output_'+str(outputId)+'.wav', '/usr/share/sounds/sf2/FluidR3_GM.sf2', '/tmp/output.mid']) call(['lame', '--preset', 'standard', '/tmp/output_'+str(outputId)+'.wav', '/tmp/output_'+str(outputId)+'.mp3']) outputId += 1 return HttpResponse(outputId-1)
def toMidi(the_input, fname): MyMIDI = MIDIFile(1) track = 0 time = 0 channel = 0 tickTime = .25 MyMIDI.addTrackName(track, time, "Sample Track") MyMIDI.addTempo(track, time, 480) the_input = the_input.transpose() flag = np.zeros((127, )) startNote = np.zeros((127, )) myTick = 0 for xMan in range(len(the_input)): myTick += tickTime for yMan in range(len(the_input[xMan])): if the_input[xMan][yMan] > 0: if flag[yMan - 1] == 0: startNote[yMan - 1] = myTick flag[yMan - 1] += tickTime else: if flag[yMan - 1] != 0: pitch = yMan time = startNote[yMan - 1] duration = flag[yMan - 1] volume = 100 MyMIDI.addNote(track, channel, pitch, time, duration, volume) print("appending: " + str(yMan) + " at " + str(time) + " for " + str(duration)) flag[yMan - 1] = 0 binfile = open(fname, 'wb') MyMIDI.writeFile(binfile) binfile.close()
def output_to_midi(OUTPUT_PATH, PRED_MIDI_PATH): predmidi = pd.read_csv(PRED_MIDI_PATH) print(predmidi.shape) mf = MIDIFile(1) # only 1 track track = 0 # the only track time = 0 # start at the beginning mf.addTrackName(track, time, "Sample Track") mf.addTempo(track, time, 120) # add some notes channel = 0 volume = 100 duration = 1 for i in range(int(predmidi.shape[0])): for j in range(int(predmidi.shape[1])): x = predmidi.iloc[i, j] if (x == 1): pitch = j time = i mf.addNote(track, channel, pitch, time, duration, volume) # write it to disk with open(OUTPUT_PATH, 'wb') as outf: mf.writeFile(outf) return 0
def makeMidi(fileName, toneLibrary, tones): """ Makes the midi file for a given set of tones """ # Create midi file tempMIDI = MIDIFile(1) track = 0 channel = 0 time = 0 # In beats tempo = 60 # In BPM volume = 100 # 0-127, as per the MIDI standard # Create the trackname and temp tempMIDI.addTrackName(track, time, fileName) tempMIDI.addTempo(track, time, tempo) # Add each tone from the current image for index, tone in enumerate(tones): # Set duration duration = .5 # Set interval between tones toneInterval = (index) * duration # Add note to track tempMIDI.addNote(track, channel, tone, time + toneInterval, duration, volume) # Write the midi track to a file with open("midiFiles/{}.mid".format(fileName), "wb") as midiFile: tempMIDI.writeFile(midiFile)
def MidiFileCreator(melody,song): bpm = melody['bpm'] pitches = melody['pitches'] parts = [t.split('.') for t in melody['times']] times = [4*int(l)+int(r)-1 for l,r in parts] durations = melody['durations'] chord_pitches = song['chord_pitches'] chord_times = song['chord_times'] chord_center = song['chord_center'] ListOfRelativeChordVoicings = song['chord_pitches'] token = melody['token'] MyMIDI = MIDIFile(1) track = 0 channel = 0 time = 0 duration = 4 volume = 100 MyMIDI.addTrackName(track,time,"Herp derp") MyMIDI.addTempo(track,time,bpm) #Sends Chords to MIDI root = int(chord_center) for chord in ListOfRelativeChordVoicings: for note in chord: Intnote = int(note + root) MyMIDI.addNote(track,channel,Intnote,time,duration,volume) time = time + 4 for note,time in zip(pitches,times): MyMIDI.addNote(track,channel,int(note),int(time),1,volume) binfile = open(base + "static/songs/" + token + ".mid", 'wb') MyMIDI.writeFile(binfile) binfile.close() return "blah"
def render(self, doc, output_file='output.mid'): ''' Produces actual output. Assumptions: separate channel for each DataObject''' # Note - I fixed a bug in MidiFile.py that was causing crashes (part of the midiutil lib). # Author confirms this is a bug, and will eventually fix and patch, but for now there's a # modified version of midiutil bundled with the project. # Create the MIDIFile Object with 1 track MyMIDI = MIDIFile(1) # Tracks are numbered from zero. Times are measured in beats. track = 0 time = 0 # Add track name and tempo. MyMIDI.addTrackName(track, time, "Sample Track") MyMIDI.addTempo(track, time, self.tempo) for channel, do in enumerate(doc): for cc_number, time_series in do.items(): for i, val in enumerate(time_series): time = float(i) / time_series.sample_rate logging.debug(str(time) + ' ' + str(val)) MyMIDI.addControllerEvent(track, channel, time, cc_number, int(val)) # And write it to disk. with open(output_file, 'wb') as binfile: MyMIDI.writeFile(binfile) return MyMIDI
def write_midi_file(self, file_object): """Writes midi generated from this tab to the given file object.""" # Throw an exception if there are note names for which we can't # determine the proper note numbers. unmappable_note_names = self.note_types.difference( self.note_name_to_number_map.keys()) if unmappable_note_names: raise UnmappableNoteNamesException(unmappable_note_names) midifile = MIDIFile(1) track = 0 channel = 9 duration = round(4.0 / self.divisions_in_bar, 10) # 4.0 is because midiutil's unit of time is the quarter note. midifile.addTrackName(track, 0, "") midifile.addTempo(track, 0, self._bpm) for note in self.walk_notes(): strike_type = note['strike_type'] volume = self._volume_for_strke_type(strike_type) if strike_type == 'r': pitch = GM_SPEC_NOTE_NAME_TO_NUMBER_MAP['Sticks'] else: pitch = self.note_name_to_number_map[note['note_type']] midifile.addNote(track, channel, pitch, note['time'], duration, volume) midifile.writeFile(file_object)
def convert_to_midi(input_file, output_file): predict_cnn(input_file) os.system( f"CNNOnsetDetector single {input_file} -o {CONVERTER_FOLDER}/onsets.txt" ) onsets = np.loadtxt(f"{CONVERTER_FOLDER}/onsets.txt") frames = np.loadtxt(f"{CONVERTER_FOLDER}/result.txt") notes = [] for i in range(onsets.shape[0]): onsets[i] = int(onsets[i] * 20) frames = np.loadtxt(f"{CONVERTER_FOLDER}/result.txt") notes = [] for i in onsets: i = int(i) for n in range(88): if i + 2 < frames.shape[0]: if (frames[i][n] > p_onset or frames[i - 1][n] > p_onset or frames[i + 1][n] > p_onset or frames[i + 2][n] > p_onset or frames[i - 2][n] > p_onset or frames[i + 3][n] > p_onset or frames[i - 3][n] > p_onset): x = i while x < frames.shape[0] and frames[x][n] > p_offset: x = x + 1 if x - i > 1: on_time = float(i / 20) off_time = float(x / 20) notes.append((n + 21, on_time, off_time)) for p in range(i, x): frames[p][n] = 1000 # plt.imshow(np.transpose(frames)[:, 200:400]) # plt.title("final transcription") # plt.show() notes = sorted(notes, key=itemgetter(2, 0)) notes_new = [] for i in range(len(notes) - 2): if i == 0: notes_new.append(notes[i]) if notes[i + 1][0] != notes[i][0]: notes_new.append(notes[i + 1]) output = MIDIFile(1) track = 0 channel = 0 volume = 100 output.addTrackName(track, 0, "Track 0") for note in notes_new: output.addNote(track, channel, note[0], note[1], note[2] - note[1], volume) midi = open(output_file, 'wb') output.writeFile(midi) midi.close()
def midiwrite(outfile, notes, tempo): track = 0 time = 0 midifile = MIDIFile(1) # Just one track for now channel = 0 volume = 100 program = 1 # Bright piano # Add track name and tempo. midifile.addTrackName(track, time, "Synth Track") midifile.addTempo(track, time, tempo) midifile.addProgramChange(track, channel, time, program) for note in notes: onset = note[0] * (tempo/60.) duration = note[1] * (tempo/60.) # duration = 1 pitch = note[2] midifile.addNote(track, channel, pitch, onset, duration, volume) # And write it to disk. binfile = open(outfile, 'wb') midifile.writeFile(binfile) binfile.close()
def create_midi(pitch): """ Creates a midi file of just one note repeated 32 times :param pitch: pitch of note :type pitch: int :returns: None :rtype: None """ MyMIDI = MIDIFile(1) track = 0 time = 0 # creates a template for a midi track MyMIDI.addTrackName(track,time, str(pitch)) MyMIDI.addTempo(track,time,120) channel = 0 volume = 120 # pitch = 60 duration = 1 for i in range(3200): MyMIDI.addNote(track,channel,pitch,time,duration,volume) time += duration # write midi file file_name = str(pitch) + '.mid' binfile = open(file_name, 'wb') MyMIDI.writeFile(binfile) binfile.close() return
def test_one_text_column(): ''' A data frame with a single integer column should be converted correctly. ''' expected = MIDIFile(1) expected.addTrackName(0,0,"vocals") expected.addTempo(0,0,120) for time,note in enumerate([38, 40, 42, 43]): expected.addNote(0,0,note,time,1,100) df = pandas.DataFrame([ {'vocals':'badger'}, {'vocals':'badger'}, {'vocals':'badger'}, {'vocals':'badger'}, {'vocals':'badger'}, {'vocals':'badger'}, {'vocals':'badger'}, {'vocals':'mushroom'}, {'vocals':'mushroom'}, ]) observed = df_to_midi(df, bpm = 120) n.assert_equal(observed, expected)
def saveMIDI(filename, noteOnsets, melody, tempo, Fs, hopSize): barOnsets = (noteOnsets*hopSize/float(Fs))*(tempo/60) #Onsets dado en barra notes = quantizeNote(melody) track = 0 time = 0 MIDI = MIDIFile(1) # Add track name and tempo. MIDI.addTrackName(track,time,"MIDI TRACK") MIDI.addTempo(track,time,tempo) channel = 0 volume = 100 for i in range(np.size(barOnsets)): pitch = notes[noteOnsets[i]+1] #leer el pitch en el siguiente frame al onset if pitch > 0: time = barOnsets[i] if i == np.size(barOnsets)-1: duration = 1 else: duration = barOnsets[i+1]-barOnsets[i] MIDI.addNote(track,channel,pitch,time,duration,volume) # And write it to disk. binfile = open(filename, 'wb') MIDI.writeFile(binfile) binfile.close()
def generate(n, program, suffix, sf="/usr/share/sounds/sf2/FluidR3_GM.sf2", volume=100): MyMIDI = MIDIFile(2) track = 0 time = 0 MyMIDI.addTrackName(track, time, "Test") MyMIDI.addTempo(track, time, 30) track = 0 channel = 0 time = 0 duration = 2.0 MyMIDI.addProgramChange(track, channel, 0, program) MyMIDI.addNote(track, channel, plist[n], 0, duration, volume) binfile = open("output.mid", 'wb') MyMIDI.writeFile(binfile) binfile.close() os.system("fluidsynth %s output.mid -F output.wav --sample-rate 1000" % sf) os.system("lame -V 7 output.wav sound%d%s.mp3" % (n, suffix)) # os.system("avconv -i output.wav -acodec sound%d%s.aac" % (n, suffix)) os.system("rm output.mid") # os.system("mplayer output.wav") os.system("mv output.wav sound%d%s.wav" % (n, suffix))
def writePiece(piece, title='Genetic Algos', filename='./pieces/untitled.mid', bpm=120, debug=False): mf = MIDIFile(1) track = 0 time = 0 mf.addTrackName(track, time, title) mf.addTempo(track, time, bpm) # add some notes channel = 0 volume = 100 for measure in piece: for note in measure: if note.midi_note is not None: mf.addNote(track, channel, note.midi_note, time, note.duration, volume) time += note.duration with open(filename, 'wb') as outf: mf.writeFile(outf) if debug: print("Writing to", fname)
def save_midi(outfile, notes, tempo): melodi_track = 0 time = 0 midifile = MIDIFile(1) midifile.addTrackName(melodi_track, time, "MELODI") midifile.addTempo(melodi_track, time, tempo) channel = 0 melodi_volume = 100 for note in notes: onset = note[0] * (tempo / 60.) duration = note[1] * (tempo / 60.) # duration = 1 pitch = int(note[2]) midifile.addNote(melodi_track, channel, pitch, onset, duration, melodi_volume) print(outfile) binfile = open(outfile, 'wb') midifile.writeFile(binfile) binfile.close()
def write_midi_file(song, file_name): """ Write a musical phrase to a MIDI file in the same directory. Uses MIDIUtil. :param song: the musical phrase to write to a file :param file_name: the name of the MIDI file """ # Create the MIDIFile Object with 1 track my_midi = MIDIFile(1) # Tracks are numbered from zero. Times are measured in beats. track = 0 time = 0 # Add track name and tempo. my_midi.addTrackName(track, time, "Main") my_midi.addTempo(track, time, MIDI_TEMPO) # Add a note. addNote expects the following information: track = 0 # (constant) channel = 0 # (constant) volume = 100 # (constant) # Now add the notes for beat in song: pitch, time, duration = beat my_midi.addNote(track, channel, pitch, time, duration, volume) # And write it to disk. if not os.path.exists('./currentRun'): os.mkdir('./currentRun') bin_file = open(file_name, 'wb') my_midi.writeFile(bin_file) bin_file.close()
def write_midi_file(song, file_name): """ Escriba una frase musical en un archivo MIDI en el mismo directorio. Utiliza MIDIUtil. : param song: la frase musical para escribir en un archivo : param file_name: el nombre del archivo MIDI """ # Crea el objeto MIDIFile con # pista my_midi = MIDIFile(12) # Las pistas están numeradas desde cero. Los tiempos se miden en latidos. beats. track = 4 time = 4 # Agrega el nombre y el tempo de la pista. my_midi.addTrackName(track, time, "Principal") my_midi.addTempo(track, time, MIDI_TEMPO) # Agrega una nota. addNote espera la siguiente información: track = 8 # (constante) channel = 2 # (constante) volume = 100 # (constante) # Ahora agrega las notas for beat in song: pitch, time, duration = beat my_midi.addNote(track, channel, pitch, time, duration, volume) # Y escribe en el disco. bin_file = open(file_name, 'wb') my_midi.writeFile(bin_file) bin_file.close()
def keysToMidi(reducedKeys): # create your MIDI object mf = MIDIFile(1) # only 1 track track = 0 # the only track time = 0 # start at the beginning mf.addTrackName(track, time, "Sample Track") mf.addTempo(track, time, random.randint(80,250)) # add some notes channel = 0 volume = 100 duration = [0.25,0.5 ,1,2] for i in range(0,len(reducedKeys)): if not len(reducedKeys[i]) == 0: for j in range(0,len(reducedKeys[i])): offset=[0,12,-12,-24] note=reducedKeys[i][j] pitch=pitchNumber[note]+random.choice(offset) mf.addNote(track, channel, pitch, time, random.choice(duration), volume) time=time+1 with open("output.mid", 'wb') as outf: mf.writeFile(outf)
def write_midi(chord_sequence, filename): # create your MIDI object mf = MIDIFile(1) # only 1 track track = 0 # the only track time = 0 # start at the beginning duration = 1 # chords will be 1 beat long mf.addTrackName(track, time, "Sample Track") mf.addTempo(track, time, 60) # add some notes channel = 0 volume = 100 for chord in chord_sequence: # Change chords to notes (list of tuples?) -> def chord_to_notes(chord) notes = chord_to_notes(chord) for note in notes: pitch = note_to_pitch(note) mf.addNote(track, channel, pitch, time, duration, volume) # Write pitches to midi file: # https://midiutil.readthedocs.io/en/latest/ # https://stackoverflow.com/questions/11059801/how-can-i-write-a-midi-file-with-python time += 2 # write it to disk with open(filename + ".mid", 'wb') as outf: mf.writeFile(outf)
def generate_midi(self, output_path: str, track_name: str = 'Sample'): mf = MIDIFile(1) # only 1 track track = 0 # the only track time_step = 0 # start at the beginning # create your MIDI object # add some notes channel = 0 volume = 100 mf.addTrackName(track, time_step, track_name) mf.addTempo(track, time_step, 120) for pcgts in self.pcgts: page = pcgts.page music_blocks = page.music_blocks() for mb in music_blocks: for line in mb.lines: symbols = line.symbols for symbol in symbols: if symbol.symbol_type == symbol.symbol_type.NOTE: duration = 0.5 # 1 1 beat long. Calculate duration based on position in image? mf.addNote(track, channel, pitch_midi_table[Pitch(symbol.note_name.value, symbol.octave)], time_step, duration, volume) time_step = time_step + duration # write it to disk with open(output_path, 'wb') as outf: mf.writeFile(outf)
class FileOutput(Output): url_example = "file://foo.mid" def __init__(self, url): Output.__init__(self) outfile = url.netloc + url.path if not outfile: print "file:// output needs a filename" raise ValueError("File output needs a filename") log.info("Opening File output: %s", outfile) self.midi = MIDIFile(1) self.midi.addTrackName(0, 0, "Mic2Mid Track 0") self.midi.addTempo(0, 0, 60) self.midi.addProgramChange(0, 0, 0, 27) self.start = time.time() self.filename = outfile def close(self): Output.close(self) log.info("Closing File output: %s", self.filename) fp = open(self.filename, "wb") self.midi.writeFile(fp) fp.close() def note_on(self, note): self.midi.addNote(0, 0, self.note_to_midi(note), time.time() - self.start, 1, 100)
def create_midi_file(ensemble, tempo): num_players = len(ensemble.G) mf = MIDIFile(num_players) channel = 0 #all on the same channel? for node in ensemble.G.nodes(): # initialize new track track = node #track index is the same as node index time = 0 #start at beginning mf.addTrackName(track, time, "Player {}".format(node)) mf.addProgramChange(track, channel, time, 42) mf.addTempo(track, time, tempo) #get player object and get data player = ensemble.G.nodes[node]['player'] data = player.data #add notes from (# note time = 0 here) for pitch, volume, duration in data: mf.addNote(track, channel, pitch, time, duration, volume) time += duration return savefile(mf)
def MidiFileCreator(melody, song): bpm = melody['bpm'] pitches = melody['pitches'] parts = [t.split('.') for t in melody['times']] times = [4 * int(l) + int(r) - 1 for l, r in parts] durations = melody['durations'] chord_pitches = song['chord_pitches'] chord_times = song['chord_times'] chord_center = song['chord_center'] ListOfRelativeChordVoicings = song['chord_pitches'] token = melody['token'] MyMIDI = MIDIFile(1) track = 0 channel = 0 time = 0 duration = 4 volume = 100 MyMIDI.addTrackName(track, time, "Herp derp") MyMIDI.addTempo(track, time, bpm) #Sends Chords to MIDI root = int(chord_center) for chord in ListOfRelativeChordVoicings: for note in chord: Intnote = int(note + root) MyMIDI.addNote(track, channel, Intnote, time, duration, volume) time = time + 4 for note, time in zip(pitches, times): MyMIDI.addNote(track, channel, int(note), int(time), 1, volume) binfile = open(base + "static/songs/" + token + ".mid", 'wb') MyMIDI.writeFile(binfile) binfile.close() return "blah"
def convertToMIDI(): # create your MIDI object midi_file = MIDIFile(1) # only 1 track track = 0 # the only track current_time = 0 # start at the beginning midi_file.addTrackName(track, current_time, "OMR Output") midi_file.addTempo(track, current_time, 120) channel = 0 for symbol in matched_symbols: #TODO check if the previous symbol is within a certain threshold x value of the current one, if so, don't play the current if "rest" in symbol.symbol_type: volume = 0 pitch = treble_notes["A4"] note_length = symbol.note_length else: volume = 100 pitch = treble_notes[symbol.pitch] note_length = symbol.note_length midi_file.addNote(track, channel, pitch, current_time, note_length, volume) current_time += note_length with open("output.mid", 'wb') as outf: midi_file.writeFile(outf)
class Generator: def __init__(self, tempo = 120): self.midi_file = MIDIFile(1) self.midi_file.addTrackName(0, 0, "track") self.midi_file.addTempo(0, 0, tempo) self.current_time = 1 def add_pause(self, length = 1): self.current_time = self.current_time + length def add_chord(self, base, notes, length = 1): for note in notes: self.midi_file.addNote(0, 0, base + note, self.current_time, length, VOLUME_TABLE[len(notes)]) self.add_pause(length) def add_pattern(self, base, pattern): for item in pattern: length = item[len(item) - 1] self.add_chord(base, item[0 : len(item) - 1], length) def write(self, filename): output_file = open(filename, 'wb') self.midi_file.writeFile(output_file) output_file.close()
def save_midi(seq,path): mf = MIDIFile(4) # only 1 track track = 1 # the only track time = 0 # start at the beginning mf.addTrackName(track, time, "Sample Track") mf.addTempo(track, time, 120) # add some notes channel = 1 volume = 100 pitch = 60 # C4 (middle C) time = 0 # start on beat 0 duration = 1 # 1 beat long mf.addNote(0, channel, pitch, time, duration, volume) pitch = 20 # E4 time = 2 # start on beat 2 duration = 1 # 1 beat long mf.addNote(2, channel, pitch, time, duration, volume) pitch = 67 # G4 time = 4 # start on beat 4 duration = 1 # 1 beat long mf.addNote(3, channel, pitch, time, duration, volume) # write it to disk with open("output.mid", 'wb') as outf: mf.writeFile(outf)
def convertNotesTomidifile(notes_list, output_file_name): # converts and stores the midi file in the folder results # create your MIDI object mf = MIDIFile(1) # 4 tracks time = 0 # start at the beginning beats_per_minute = 120 mf.addTrackName(0, time, "Track 1") mf.addTempo(0, time, beats_per_minute) # initialize a list which stores notes, and only adds them to the midi after the full duration is known note_storage = Note() max_iter = 1000 i = 0 for note in notes_list: i += 1 track_pitch = int(note) current_note = note_storage if track_pitch == current_note.pitch: current_note.add_dur() note_storage = current_note else: add_note_to_track(0, current_note, mf) note_storage = Note(time, track_pitch) time += tick_length # move 1/4 beat into the future # After text file ends, add the remaining notes add_note_to_track(0, note_storage, mf) # write it to disk with open("results/" + output_file_name + ".mid", 'wb') as outf: mf.writeFile(outf)
def midisaver(): print("s = Save n = New Sequence q = Quit") while True: choice = input("> ") if choice == 's': oldvoices = list(voices) mf = MIDIFile(4) time = 0 tracklist = [0, 1, 1, 1, 1, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2] tracknames = ['Bass', 'Drums', 'Keys', 'Lead'] for i in range(len(oldvoices)): track = tracklist[i] mf.addTrackName(track, 0, tracknames[track]) mf.addTempo(track, 0, bpm) channel = 0 for x in range(len(oldvoices[i])): if oldvoices[i][x][1] != 0: pitch = oldvoices[i][x][1] volume = oldvoices[i][x][2] time = oldvoices[i][x][0]/4 #convert from beats to sixteenths if time+1 > 8: duration = oldvoices[i][x][3] else: duration = random.choice([0.20, 0.40, 0.60, 0.80, 1]) mf.addNote(track, channel, pitch, time, duration, volume) filename = (input('Save As:') + ".mid") with open(filename, 'wb') as outf: mf.writeFile(outf) if choice == 'q': thread.interrupt_main() sys.exit() if choice == 'n': measureCount = 1 compose()
def playMIDI(x,counter,counter2, O): from midiutil.MidiFile import MIDIFile MyMIDI=MIDIFile(1, removeDuplicates=False, deinterleave=False) track=0 time=0 MyMIDI.addTrackName(track,time,"Sample") MyMIDI.addTempo(track,time,60) track=0 channel=0 a=North[x] b=East[x] c=West[x] averagex=round(((a+b+c)/3),0) pitchcalc=pitchnum(averagex) pitch=pitchcalc timecalc,O=deltatime(counter, O) time=2 duration=timecalc if counter2==0: volume=10*(int(round(math.pow(North[x],1.0/3)))) elif counter2==1: volume=10*(int(round(math.pow(East[x],1.0/3)))) elif counter2==2: volume=10*(int(round(math.pow(West[x],1.0/3)))) else: print("numcount error", counter2) volume=127 MyMIDI.addNote(track,channel,pitch,time,duration,volume) outcount=str(counter) numcount=str(counter2) binfile=open(outpath+"/output "+outcount+" "+numcount+".mid",'wb') MyMIDI.writeFile(binfile) print(counter,"\n",track,channel,pitch,time,duration,volume) binfile.close() return O
def save_midi(outfile, notes, tempo): track = 0 time = 0 midifile = MIDIFile(1) # Add track name and tempo. midifile.addTrackName(track, time, "MIDI TRACK") midifile.addTempo(track, time, tempo) channel = 0 volume = 100 for note in notes: onset = note[0] * (tempo/60.) duration = note[1] * (tempo/60.) # duration = 1 pitch = note[2] pitch = pitch.__int__() midifile.addNote(track, channel, pitch, onset, duration, volume) # And write it to disk. binfile = open(outfile, 'wb') midifile.writeFile(binfile) binfile.close()
def write_midi(note_vals, total_dist, total_time, musicfile): """ TO BE DEPRECATED """ # create your MIDI object mf = MIDIFile( 1, adjust_origin=True) # only 1 track, changed adjust_origin to T track = 0 # the only track time = 0 # start at the beginning time_factor = total_time / total_dist mf.addTrackName(track, time, "Sample Track") mf.addTempo(track, time, (1 / time_factor)) channel = 0 note_conversion = {0: 60, 1: 62, 2: 64, 3: 67, 4: 69} for i in note_vals: # add some notes pitch = note_conversion[i[1]] time = i[0][0] * time_factor duration = 4 # can be parameterized volume = 100 # can be parameterized mf.addNote(track, channel, pitch, time, duration, volume) ''' http://stackoverflow.com/questions/11059801/how-can-i-write-a-midi-file-with-python how to write a note (each pitch # is a piano key) pitch = 60 # C4 (middle C) time = 0 # start on beat 0 duration = 1 # 1 beat long mf.addNote(track, channel, pitch, time, duration, volume) ''' # write it to disk with open(musicfile, 'wb') as outf: mf.writeFile(outf)
def generateMidiFile(songNoteLst, MCType): print("Generating Song File") newSong = MIDIFile(1) # Tracks are numbered from zero. Times are measured in beats. track = 0 time = 0 # Add track name and tempo. newSong.addTrackName(track, time, "Song Generated Using Markov Chain") newSong.addTempo(track, time, 360) channel = 0 for note in songNoteLst: if note != -1: # Add a note. addNote expects the following information: pitch = note duration = random.randint(1,4) volume = 255 # Now add the note. newSong.addNote(track,channel,pitch,time,duration,volume) time += duration # And write it to disk. write_file_name = "output_" + MCType + "_MC.midi" binfile = open(write_file_name, 'wb') newSong.writeFile(binfile) binfile.close() print("Finished")
def matrix_to_midi(notes, filename='matrix.mid', tempo=60): """ Simplify midi generation note format: PITCH|START|DURATION|VOLUME """ # Midi file with one track mf = MIDIFile(1) track = 0 time = 0 mf.addTrackName(track, time, filename[7:-4]) # Default # FIXME tempo -- time relation is not well defined mf.addTempo(track, time, tempo) channel = 0 time_per_tick = 2**-5 for note in notes: pitch = note[0] start = note[1] * time_per_tick stop = note[2] * time_per_tick vol = note[3] mf.addNote(track, channel, pitch, start, stop, vol) # Save as file with open(filename, 'wb') as fout: mf.writeFile(fout)
def matrix_to_midi(notes, filename = 'matrix.mid', tempo = 60): """ Simplify midi generation note format: PITCH|START|DURATION|VOLUME """ # Midi file with one track mf = MIDIFile(1) track = 0 time = 0 mf.addTrackName(track, time, filename[7:-4]) # Default # FIXME tempo -- time relation is not well defined mf.addTempo(track, time, tempo) channel = 0 time_per_tick = 2**-5 for note in notes: pitch = note[0] start = note[1] * time_per_tick stop = note[2] * time_per_tick vol = note[3] mf.addNote(track, channel, pitch, start, stop, vol) # Save as file with open(filename, 'wb') as fout: mf.writeFile(fout)
def make_song_file(mood, key, syllables): # create the MIDIFile object with 1 track MyMIDI = MIDIFile(1) if mood == "mood1": mood = pass1 elif mood == "mood2": mood = happy1 elif mood == "mood3": mood = cool1 # tracks are numbered from zero. times are measured in beats. track = 0 time = 0 # add track name and tempo. MyMIDI.addTrackName(track, time, "Sample Track") MyMIDI.addTempo(track, time, 100) key = key % 12 MyMIDI = add_chords(MyMIDI, mood, key) MyMIDI = add_notes(MyMIDI, syllables, key, mood) # and write it to disk. binfile = open("song.mid", "wb") MyMIDI.writeFile(binfile) binfile.close()
class Midi: """Musique midi""" def __init__(self, partition, titre, tempo): # Définition des paramètres MIDI. piste = 0 temps = 0 self.tempo = tempo / 2 self.sortiemidi = MIDIFile(1, file_format=1) # Nom de la piste. self.sortiemidi.addTrackName(piste, temps, sansaccents(titre)) # Tempo. self.sortiemidi.addTempo(piste, temps, self.tempo) # Instrument (74 : flûte). self.sortiemidi.addProgramChange(piste, 0, temps, 74) self.traiter_partition(partition, piste, temps) def traiter_partition(self, partition, piste, temps): """Création des évènements MIDI""" transposition = partition.transposition channel = 0 volume = 127 for mot in partition: for i, syllabe in enumerate(mot): syl = str(syllabe) if i + 1 < len(mot): syl = syl + '-' for j, note in enumerate( notes for notes in syllabe.musique if isinstance(notes, Note) ): pitch = note.hauteur + transposition duree = int(note.duree) self.sortiemidi.addTempo( piste, temps, (self.tempo * duree / note.duree) ) self.sortiemidi.addNote( piste, channel, pitch, temps, duree / 2, volume ) if j == 0: self.sortiemidi.addText( piste, temps, syl ) temps += duree / 2 def ecrire(self, chemin): """Écriture effective du fichier MIDI""" with ( open(sys.stdout.fileno(), 'wb') if chemin == '-' else open(chemin, 'wb') ) as sortie: self.sortiemidi.writeFile(sortie)
def run(self): inputObj = self.get_input("input") #obiekt interfejsu wejściowego outputGraph = self.get_output("outputGraph") #obiekt interfejsu wyjściowego outputPitch = self.get_output("outputPitch") #obiekt interfejsu wyjściowego prev_note = 0 #init midi track = 0 time = 0 MyMIDI = MIDIFile(1) MyMIDI.addTrackName(track,time,"Sample Track") MyMIDI.addTempo(track,time,120) try: while self.running(): data_input = inputObj.read() N = data_input["N"] audioData = base64.b64decode(data_input["data"]) MAX_y = data_input["MAX_y"] y = np.array(struct.unpack("%dh" % (N * CHANNELS), audioData)) / MAX_y y_L = y[::2] y_R = y[1::2] Y_L = np.fft.fft(y_L, nFFT) Y_R = np.fft.fft(y_R, nFFT) # Łączenie kanałów FFT, DC - prawy kanał Y = abs(np.hstack((Y_L[-nFFT/2:-1], Y_R[:nFFT/2]))) samples = np.fromstring(audioData, dtype=np.int16) #wyliczenie dzwieku rawnote = analyse.musical_detect_pitch(samples) if rawnote is not None: note = np.rint(rawnote) #wyślij nutę na wyjście outputPitch.send(note) if note != prev_note: #MyMIDI.addNote(track,channel,pitch,time,duration,volume) MyMIDI.addNote(0,0,note,time,1,100) time+=1 prev_note = note output = {"db_table": list(Y)} outputGraph.send(output) #save midi on exit except: binfile = open("output.mid", 'wb') MyMIDI.writeFile(binfile) binfile.close()
def initializeTrack(tempo=100, numTracks=15): """Create a song with the given tempo.""" song = MIDIFile(numTracks) time = 0 for track in range(numTracks): song.addTrackName(track, time, "Track " + str(track)) song.addTempo(track, time, tempo) return song
def reset_track(self): if self.track: del self.track self.track = None track = MIDIFile(1) track.addTrackName(0, 0, "beatfruit-recording") # FIXME: Use a nicer name, template it and include timestamp??? track.addTempo(0, 0, 120) # FIXME: Will impliment tempo changes later! self.track = track self.events = [] self.chans = {} self.last_timestamp = None self.base_time = None
def playingmusic(O): from midiutil.MidiFile import MIDIFile MyMIDI=MIDIFile(1, removeDuplicates=False, deinterleave=False) track=0 time=0 MyMIDI.addTrackName(track,time,"Sample") MyMIDI.addTempo(track,time,120) for x in range(0,3000): counter=x for midout in range(0,3): O,MyMIDI,vol,pitch,time=playMIDI(x,counter, midout, O, MyMIDI) print(counter, midout, pitch, vol, time) return O,MyMIDI
def convertToMIDI(piece): mfile = MIDIFile(1) track = 0 time = 0 tempo = 160 mfile.addTrackName(track, time, "test") mfile.addTempo(track, time, tempo) channel = 0 volume = 100 # Actual magic happens here i = 0 while i < len(piece)-1: # Get the corresponding pitch for the note pitch = mapping[piece[i][0]] diff = int(piece[i][-1]) - 4 pitch += diff * 12 # If we're dealing with a continued note if piece[i] == piece[i+1]: n = i duration = 0 # Keep increasing the duration by 2 for # every consecutive matching note while piece[n] == piece[n+1]: #print n duration += 2 if n+1 == len(piece): break # Single note duration is 2 n += 1 mfile.addNote(track, channel, pitch, i*2, duration, volume) i = n # If we're dealing with a single note, add it else: mfile.addNote(track, channel, pitch, i*2, 2, volume) # If we're on the penultimate note, # add the last note too if i == len(piece) - 1: pitch = mapping[piece[i+1]] mfile.addNote(track, channel, pitch, i*2, 2, volume) i += 1 bfile = open("output.mid", "wb") mfile.writeFile(bfile) bfile.close()
def WriteMidi(notes, tempo, file): MyMIDI = MIDIFile(1) MyMIDI.addTrackName(0,0,"Sample Track") MyMIDI.addTempo(0,0,tempo) time= 0 for (name, d, length) in notes: MyMIDI.addNote(0,0,60,time,length*4,100) time+= length*4 binfile = open(file, 'wb') MyMIDI.writeFile(binfile) binfile.close()
def write_midi(filename, sequence): filename = "music/"+filename midi = MIDIFile(1) track = 0 start_time = 0 midi.addTrackName(track, start_time, filename[:-4]) tempo = random.randrange(120, 480) midi.addTempo(track, start_time, tempo) for seq in range(len(sequence)): for note in sequence[seq]: midi.addNote(track, 9, note.pitch, note.time, note.duration, note.volume) # midi.addProgramChange(0, seq, 0, instrList[seq]) f = open(filename, 'w') midi.writeFile(f) f.close()
def write_song(song, dest, tempo=240): num_channels = len(song) midi_scratch_file = MIDIFile(num_channels) for i in range(0, num_channels): midi_scratch_file.addTrackName(i, 0, "Pop Flute {0}".format(i)) midi_scratch_file.addTempo(i, 0, tempo) time = 0 for x in range(0, song_length(song)): duration = 0.5 pitch = song[i][x] midi_scratch_file.addNote(i, i, pitch, time, duration, 100) time += duration bin_file = open(dest, 'w') midi_scratch_file.writeFile(bin_file) bin_file.close()
def handle_score(score): parts = score.findall('part-list/score-part') midiparts = [] for part in parts: actualpart = score.find('part[@id="%s"]' % part.get('id')) tuning = handle_tuning(actualpart) trackname = gettext(part.find('part-name')) midipart = MIDIFile(1) midipart.addTrackName(0, 0, trackname) midipart.name = trackname for channel, _ in enumerate(tuning): midipart.addProgramChange(0, channel, 0, getint(part.find('.//midi-program'))) midipart.addTempo(0, 0, 120) handle_measures(midipart, actualpart, tuning) midiparts.append(midipart) return midiparts
def write_midi(filename, sequence): filename = "markov/"+filename midi = MIDIFile(1) track = 0 start_time = 0 midi.addTrackName(track, start_time, filename[:-4]) tempo = random.randrange(360, 480) midi.addTempo(track, start_time, tempo) midi.addProgramChange(0, 0, 0, 1) for i in range(len(sequence)): note = sequence[i] midi.addNote(track, 0, note.pitch, note.time, note.duration, note.volume) f = open(filename, 'w') midi.writeFile(f) f.close()
def export_midi(self, file_path): """Export a MIDI file.""" midi = MIDIFile(1) midi.addTrackName(0, 0, self.metadata.get('OTL')) midi.addTempo(0, 0, 80) for i, part in enumerate(self.parts): non_rests = [ d for d in part['data'] if d['pitch'] != 'r' ] for note in non_rests: midi.addNote(track=0, channel=i, pitch=note['midinote'], time=note['beat'], duration=note['duration'], volume=80) with open(file_path, 'wb') as binfile: midi.writeFile(binfile)
def writeMID(filename, tempo, notes): # Create the MIDIFile Object with 1 track MyMIDI = MIDIFile(1) # Tracks are numbered from zero. Times are measured in beats. track = 0 time = 0 # Add track name and tempo. MyMIDI.addTrackName(track,time,"Sample Track") MyMIDI.addTempo(track,time,tempo) writeNotes(MyMIDI, notes) # And write it to disk. binfile = open(filename, 'wb') MyMIDI.writeFile(binfile) binfile.close()
def generate_mesure_pattern(pattern=[(1, 1, 0, 48), (3, 1, 1, 48), (5, 1, 2, 48), (7, 1, 3, 48)], gamme=0): # Create the MIDIFile Object with 1 track MyMIDI = MIDIFile(1) # Tracks are numbered from zero. Times are measured in beats. track = track time = 0 # Add track name and tempo. MyMIDI.addTrackName(track, time, "Sample Track") MyMIDI.addTempo(track, time, 120) # Add a note. addNote expects the following information: track = track channel = 0 # pitch = note generée time = 0 duration = 1 volume = 100 # Now add the note. MyMIDI.addNote(track, channel, pitch, time, duration, volume) print("lapin") # And write it to disk. binfile = open("output.mid", "wb") MyMIDI.writeFile(binfile) binfile.close()
def patterns_to_midi_v2(patterns, midi_out): num_tracks = len(patterns) midi = MIDIFile(num_tracks) tempo = 120 duration = 1 # track, time, name midi.addTrackName(0, 0, "Track0") # track, time, tempo midi.addTempo(0, 0, tempo) for pattern_id, pattern in patterns.items(): onsets = np.array([ i for i in range(len(pattern)) if pattern[i] == 1 ]) for onset in onsets: midi.addNote(0, 0, pattern_id, onset, duration, 127) with open(midi_out, 'wb') as f: midi.writeFile(f)
def test_one_int_column(): ''' A data frame with a single integer column should be converted correctly. ''' expected = MIDIFile(1) expected.addTrackName(0,0,"guitar") expected.addTempo(0,0,120) for time,note in enumerate([38, 40, 42, 43]): expected.addNote(0,0,note,time,1,100) df = pandas.DataFrame([ {'guitar':38}, {'guitar':40}, {'guitar':42}, {'guitar':43}, ]) observed = df_to_midi(df, bpm = 120) assert_midi_equal(observed, expected)
class Midi: def __init__(self): # Create the MIDIFile Object with 1 track self.midi = MIDIFile(1) # Tracks are numbered from zero. Times are measured in beats. track = 0 time = 0 # Add track name and tempo. self.midi.addTrackName(track,time,"Sample Track") self.midi.addTempo(track,time,120) self.timer = 0 def add_note(self, pitch, duration, track = 0, channel = 0, volume = 100): # Now add the note. self.midi.addNote(track, channel, self.pitch_to_midi(pitch), self.timer, duration, volume) self.timer += duration*2 def write(self): # And write it to disk. binfile = open("output.mid", 'wb') self.midi.writeFile(binfile) binfile.close() def pitch_to_midi(self, note): return { "A3" : 57, "B3" : 59, "C3" : 48, "D3" : 50, "E3" : 52, "F3" : 53, "G3" : 55, "A4" : 69, "B4" : 71, "C4" : 60, "D4" : 62, "E4" : 64, "F4" : 65, "G4" : 67, }[note]