def midi_decode(grid): pattern = midi.Pattern() track = midi.Track() tempoEvent = midi.SetTempoEvent() tempoEvent.set_bpm(30) track.append(tempoEvent) pattern.append(track) previous_vector = grid[0] # first vector for note_index in range(len(previous_vector)): if previous_vector[note_index] != 0: #velocity is not 0 track.append(midi.NoteOnEvent(tick=0, velocity=previous_vector[note_index], pitch=note_index)) tickoffset = 0 for vector in grid: if previous_vector == vector: #if vectors are same, no new events tickoffset += 1 else: for note_index in range(len(previous_vector)): if previous_vector[note_index] == vector[note_index]: #if same velocity, hold the note rather than rearticulate (no new event) continue if previous_vector[note_index] != 0 and vector[note_index] == 0: if note_index > 127: print "BROKEN ASSUMPTION" track.append(midi.NoteOffEvent(tick=tickoffset, pitch=note_index)) else: track.append(midi.NoteOnEvent(tick=0, velocity=vector[note_index], pitch=note_index)) tickoffset = 0 tickoffset += 1 previous_vector = vector track.append(midi.EndOfTrackEvent(tick=1)) return pattern
def generate_random_midi(): pattern = midi.Pattern(resolution=220) track = midi.Track() pattern.append(track) ticks = 0 tick_buffer = 0 pitches = [-1] * NEURAL_NET_DELAY #use -1 to indicate a rest set_tempo = midi.SetTempoEvent() set_tempo.set_bpm(TEMPO) track.append(set_tempo) while ticks < NUM_TICKS: duration = random.randint(*DURATION_RANGE) volume = random.randint(*VOLUME_RANGE) pitch = random.randint(*PITCH_RANGE) if duration + ticks > NUM_TICKS: duration = NUM_TICKS - ticks ticks += duration tick_buffer += duration while tick_buffer > 0: tick_buffer -= TICKS_PER_WINDOW pitches.append(pitch - PITCH_RANGE[0]) on = midi.NoteOnEvent(tick=0, velocity=volume, pitch=pitch) off = midi.NoteOffEvent(tick=duration, pitch=pitch) track.extend([on, off]) eot = midi.EndOfTrackEvent(tick=1) track.append(eot) return (pattern, pitches)
def finalize_midi_sequence(ptrn, name="Track 1", inst=0, channel=0, tsig=(4, 4), bpm=120): """ Makes a geenrated midi sequnce valid for most players by adding TimeSignature, SetTempo and EndOfTrack events. """ has_tsig = False has_tempo = False has_end = False for evnt in utils.evnt_gen(ptrn): if isinstance(evnt, midi.SetTempoEvent): has_tsig = True if isinstance(evnt, midi.TimeSignatureEvent): has_tempo = True if isinstance(evnt, midi.EndOfTrackEvent): has_end = True if not has_tsig: ptrn[0].insert(0, midi.TimeSignatureEvent(tick=0)) ptrn[0][0].data[:2] = tsig ptrn[0][0].data[2:] = 24, 8 if not has_tempo: ptrn[0].insert(0, midi.SetTempoEvent(tick=0)) ptrn[0][0].set_bpm(bpm) if not has_end: ptrn[0].append(midi.EndOfTrackEvent(tick=0)) ptrn[0].insert(0, midi.TrackNameEvent(tick=0, text=name, data=[])) ptrn[0].insert( 0, midi.ProgramChangeEvent(tick=0, channel=channel, data=[inst])) return ptrn
def _set_tempo(track, value): """ 设置一个自己写的Track的Tempo """ SetTempoEvent = midi.SetTempoEvent(bpm=value) track.insert(0, SetTempoEvent) return track
def list_to_midi(chunk_str_list, generated_dir, filename): pattern = midi.Pattern(resolution=480) track = midi.Track() pattern.append(track) for chunk in chunk_str_list: chunk_info = chunk.split("_") event_type = chunk_info[1] if event_type == "no": tick = int(chunk_info[0]) pitch = int(chunk_info[2]) velocity = int(chunk_info[3]) e = midi.NoteOnEvent(tick=tick, channel=0, velocity=velocity, pitch=pitch) track.append(e) elif event_type == "st": tick = int(chunk_info[0]) bpm = int(chunk_info[2]) mpqn = int(chunk_info[3]) ev = midi.SetTempoEvent(tick=tick, bpm=bpm, mpqn=mpqn) track.append(ev) elif event_type == "cc": control = int(chunk_info[3]) value = int(chunk_info[4]) e = midi.ControlChangeEvent(channel=0, control=control, value=value) track.append(e) end_event = midi.EndOfTrackEvent(tick=1) track.append(end_event) midi.write_midifile(generated_dir + filename + '.mid', pattern)
def test_1(): print("[%s:%d] test_1()" % \ (os.path.basename(libs.thisfile()), libs.linenum() ), file=sys.stderr) file = "test.mid" pattern = midi.Pattern(resolution=960) #このパターンがmidiファイルに対応しています。 track = midi.Track() #トラックを作ります pattern.append(track) #パターンに作ったトラックを追加します。 ev = midi.SetTempoEvent(tick=0, bpm=120) #テンポを設定するイベントを作ります track.append(ev) #イベントをトラックに追加します。 e = midi.NoteOnEvent(tick=0, velocity=100, pitch=midi.G_4) #ソの音を鳴らし始めるイベントを作ります。 track.append(e) e = midi.NoteOffEvent(tick=960, velocity=100, pitch=midi.G_4) #ソの音を鳴らし終えるイベントを作ります。 track.append(e) eot = midi.EndOfTrackEvent(tick=1) #トラックを終えるイベントを作ります track.append(eot) midi.write_midifile(file, pattern) #パターンをファイルに書き込みます。
def main(): composerName = "mozart" createNewTransition = False inputFiles = glob.glob('midis/midiworld/classic/' + composerName + '*.mid') if createNewTransition: getTransitionMatrix(inputFiles, composerName) lengthM = loadMatrixFromFile("matrices/" + composerName + "LengthM.dat") pitchM = loadMatrixFromFile("matrices/" + composerName + "PitchM.dat") velocityM = loadMatrixFromFile("matrices/" + composerName + "VelocityM.dat") notesList = highestPlausibility(lengthM, pitchM, velocityM) outFileName = "midis/" + composerName + "New.mid" # Instantiate a MIDI Pattern (contains a list of tracks) resolution = 384 pattern = midi.Pattern(resolution=resolution) # Instantiate a MIDI Track (contains a list of MIDI events) track = midi.Track() # Append the track to the pattern pattern.append(track) # Set Instrument to piano pEvent = midi.ProgramChangeEvent(tick=0, channel=0) pEvent.set_value(1) track.append(pEvent) # Set tempo to 150 bpm tEvent = midi.SetTempoEvent(tick=0) tEvent.set_bpm(150) track.append(tEvent) for note in notesList: tick = Note.lengthToTick(note.length, resolution) pitch = note.pitch velocity = note.volume # Append the new note track.append( midi.NoteOnEvent(channel=0, tick=0, pitch=pitch, velocity=velocity)) # Stop the previous note to avoid unpleasant mixing track.append( midi.NoteOnEvent(channel=0, tick=tick, pitch=pitch, velocity=0)) # Add the end of track event, append it to the track eot = midi.EndOfTrackEvent(tick=0) track.append(eot) print pattern # Save the pattern to disk midi.write_midifile(outFileName, pattern) print "\nMusic written to " + outFileName + "\n"
def numpy2midi(X, midifile, bpm=155): # pad to fill last bar (we fill to 16th) padded_dim = -16 * ( -X.shape[0] // 16 ) # remainder of negative numbers equals to ceil() instead of floor() X_padded = np.zeros((padded_dim, X.shape[1]), dtype=int) X_padded[:X.shape[0], :X.shape[1]] = X X = X_padded # find for each timestep the set of on-notes X = [set(np.nonzero(x)[0]) for x in X] # prepend and append an empty step to the song X.insert(0, set()) X.append(set()) conductor = midi.Track() time_sig = midi.TimeSignatureEvent(tick=0, numerator=4, denominator=4, metronome=24, thirtyseconds=8) conductor.append(time_sig) tempo = midi.SetTempoEvent(tick=0, bpm=bpm) conductor.append(tempo) track = midi.Track() tick = 0 for previous, current in zip(X[:-1], X[1:]): notes_to_off = previous - current # notes in the previous but not in the current (ending notes) for pitch in map(_index2pitch, notes_to_off): off = midi.NoteOffEvent( tick=tick, pitch=pitch, velocity=0) # velocity is ignored in NoteOffEvents track.append(off) tick = 0 notes_to_on = current - previous # notes in the current but not in the previous (beginning notes) for pitch in map(_index2pitch, notes_to_on): on = midi.NoteOnEvent(tick=tick, pitch=pitch, velocity=100) track.append(on) tick = 0 tick += 1 # end of track event eot = midi.EndOfTrackEvent(tick=0) conductor.append(eot) track.append(eot) # instantiate a MIDI Pattern (contains a list of tracks) pattern = midi.Pattern(resolution=4) # append the track to the pattern pattern.append(conductor) pattern.append(track) # save the pattern to disk midi.write_midifile(midifile, pattern)
def _initialize_or_reset_state(self): self.track_uuid = str(uuid.uuid4())[0:7] self.pattern = midi.Pattern(resolution=self.pc.resolution) self.track = midi.Track() self.pattern.append(self.track) self.track.append(midi.SetTempoEvent(bpm=self.bpm)) self.track.append( midi.TimeSignatureEvent( numerator=self.time_signature_numerator, denominator=self.time_signature_denominator))
def generate_tempo_track(data, length, mpqn=20): track = midi.Track() track.append(midi.TrackNameEvent()) track.append(midi.TextMetaEvent()) te = midi.SetTempoEvent() te.tick = length te.set_mpqn(mpqn) track.append(te) track.append(midi.EndOfTrackEvent()) return track
def split_on_timesignature_change(x, typ, include_end=True): """ Partitions a midi.Track into different midi.Tracks depending on the occurance of typ (a particular midi.events type). For example, one may split a single track into smaller tracks that have different time signatures. """ if isinstance(x, midi.Pattern): trck = x[0] mode = "ptrn" elif isinstance(x, utils.MidiObj): assert len(x.ptrn) == 1 trck = x.ptrn[0] mode = "midi_obj" else: trck = x mode = "trck" trck.make_ticks_abs() new_trck = midi.Track(tick_relative=False) tempo = midi.SetTempoEvent() tmp_flag = False typ_flag = False output = [new_trck] cache = [] tick = trck[0].tick args = [output, new_trck, cache, tempo, tmp_flag, typ_flag] for evnt in trck: if evnt.tick != tick: tick = evnt.tick args = aux_split_timestep(*args, include_end) args[2].append(copy.copy(evnt)) # encountered type on which to split? if isinstance(evnt, typ): args[5] = typ_flag = True # does the tempo change and therefore need updating? if isinstance(evnt, midi.SetTempoEvent): args[4] = tmp_flag = True args[3] = tempo = evnt output = aux_split_timestep(*args, include_end)[0] ret = [] for trck in output: trck.make_ticks_rel() trck[0].tick = 0 if mode == "ptrn": ptrn = copy_ptrn(x) ptrn.append(trck) ret.append(ptrn) elif mode == "midi_obj": ptrn = copy_ptrn(x.ptrn) ptrn.append(trck) midi_obj = utils.MidiObj(ptrn) ret.append(midi_obj) else: ret = output return ret
def init_midi(speed): # init an midi global pattern global track pattern = midi.Pattern( format=1, resolution=96) # FL Studio's midi's resolution is 96. track = midi.Track() pattern.append(track) track.append(midi.SetTempoEvent(tick=0, data=[ speed, 0, 0 ])) # TODO:Discover what it is, and give a tempo option.
def _events_to_midi_multitrack(starts, durs, pitches, velocities=90, tracks=0, channels=0, tempo=60, resolution=1920, outfile="events.mid"): import midi N = len(starts) as_seq = lambda obj: [obj] * N if isinstance(obj, Number) else obj time2tick = lambda time: int(time * resolution) pitches, durs, velocities, tracks, channels = map(as_seq, [pitches, durs, velocities, tracks, channels]) numtracks = max(tracks) + 1 miditracks = [] pitches = list(map(asmidi, pitches)) for tracknum in range(numtracks): t = midi.Track() t.make_ticks_abs() t.append(midi.SetTempoEvent(tick=0, bpm=tempo)) miditracks.append(t) notespertrack = [[] for _ in miditracks] for i in range(len(starts)): track = tracks[i] ev = _Event(starts[i], durs[i], pitches[i], velocities[i], channels[i]) notespertrack[track].append(ev) for notes in notespertrack: notes.sort() for j in range(len(notes) - 1): note0, note1 = notes[j], notes[j + 1] if note0.start + note0.dur > note1.start: notes[j] = note0._replace(dur=note1.start - note0.start) for tracknum, notes in enumerate(notespertrack): if not notes: continue t = miditracks[tracknum] for note in notes: t.append(midi.NoteOnEvent(tick=time2tick(note.start), pitch=note.pitch, velocity=note.vel)) t.append(midi.NoteOffEvent(tick=time2tick(note.start + note.dur), pitch=note.pitch)) t.append(midi.EndOfTrackEvent(tick=time2tick(notes[-1].start + notes[-1].dur) + 1)) midipattern = midi.Pattern(miditracks, resolution=resolution) midipattern.make_ticks_rel() midi.write_midifile(outfile, midipattern) return midipattern
def generate_midi(data, filename): eigth_note = 96 // 2 instrument = 1 # 1 - grand piano # 5 - electric piano # 41 - violin # 27 - electric guitar pattern = midi.Pattern(resolution=eigth_note) track = midi.Track() track.append(midi.ProgramChangeEvent(tick=0, data=[instrument])) pattern.append(track) set_tempo_event = midi.SetTempoEvent(tick=0) set_tempo_event.bpm = 200 track.append(set_tempo_event) last = 0 for step in range(data.shape[0] + 1): for note in range(128): last_note_on = (step > 0 and data[step - 1, note] == 1) note_on = (step < data.shape[0] and data[step, note] == 1) if note_on and not last_note_on: tick = 0 if last != step: tick = (step - last) * eigth_note last = step track.append( midi.NoteOnEvent(tick=tick, velocity=90, pitch=note)) if not note_on and last_note_on: tick = 0 if last != step: tick = (step - last) * eigth_note last = step track.append(midi.NoteOffEvent(tick=tick, pitch=note)) track.append(midi.EndOfTrackEvent(tick=eigth_note)) midi.write_midifile(f"{filename}.mid", pattern) subprocess.call([ "fluidsynth", "-F", f"{filename}.wav", "GeneralUser GS MuseScore v1.442.sf2", f"{filename}.mid" ]) # subprocess.call(["rm", f"{filename}.mid"]) subprocess.call(["open", f"{filename}.wav"])
def toMidi(self): print("called toMidi") print(self.noteName) # create midi pattern and track pattern = midi.Pattern() track = midi.Track() pattern.append(track) # append note events to the track print("start appending note events") tempo = midi.SetTempoEvent() tempo.set_bpm(self.bpm) track.append(tempo) rest = 0 for i in range(len(self.noteName)): if self.noteName[i] == []: rest += 1 for j in range(len(self.noteName[i])): on = midi.NoteOnEvent(tick=0 + (rest * self.resolution), velocity=self.constVelocity, pitch=self.noteName[i][j]) track.append(on) rest = 0 for k in range(len(self.noteName[i])): if k == 0: off = midi.NoteOffEvent(tick=self.resolution, pitch=self.noteName[i][k]) else: off = midi.NoteOffEvent(tick=0, pitch=self.noteName[i][k]) track.append(off) # create eot print("creating eot...") eot = midi.EndOfTrackEvent(tick=1) track.append(eot) print("This is the pattern") print(pattern) # save the pattern to ./output.mid print("Saving ...") midi.write_midifile(self.export + '.mid', pattern) print("Conversion finished")
def makeSongMidi(song, instruments, volume, name, bpm): ''' song is a list of lists of pysynth tuples instruments is a list of ints specifying midi instruments; -1 means to use channel 9 to produce percussion sounds volume is a list of ints specifying the volume of each track name is the song's name ''' # 220 is completely arbitrary. anything >= 4 should probably work resolution = 220 pattern = midi.Pattern(resolution=resolution) tempoEvent = midi.SetTempoEvent(tick=0) tempoEvent.set_bpm(bpm) tempoTrack = midi.Track() tempoTrack.append(tempoEvent) tempoTrack.append(midi.EndOfTrackEvent(tick=0)) pattern.append(tempoTrack) for i in range(len(song)): track = midi.Track() if instruments[i] != -1: track.append( midi.ProgramChangeEvent(tick=0, channel=i, data=[instruments[i]])) for note in song[i]: noteLetter = note[0][:-1] noteNum = chromNotesNum[noteLetter] - 1 octave = int(note[0][-1]) pitch = noteNum + (octave - 1) * 12 ticks = int(durationToBeats(note[1]) * resolution) if instruments[i] != -1: track.append( midi.NoteOnEvent(tick=0, channel=i, data=[pitch, volume[i]])) track.append( midi.NoteOffEvent(tick=ticks, channel=i, data=[pitch, 0])) else: track.append( midi.NoteOnEvent(tick=0, channel=9, data=[pitch, volume[i]])) track.append( midi.NoteOffEvent(tick=ticks, channel=9, data=[pitch, 0])) track.append(midi.EndOfTrackEvent(tick=0)) pattern.append(track) midi.write_midifile('midi/' + name + '.mid', pattern)
def __init__(self): print "BPM: %d" % args.bpm self.pattern = midi.Pattern() self.track = midi.Track() self.flam = False self.accent = False self.rest_beats = 1 self.outputFile = args.output self.pattern.append(self.track) self.note_tightness = args.note_tightness self.rest = self.one_beat_value/self.beat_values_new["1/4"][1] tempo = midi.SetTempoEvent() tempo.set_bpm(args.bpm) self.track.append(tempo)
def midiFromLabels(labels, interval=DEFAULT_INTERVAL): """Method to take output of our system and create a MIDI file we can put through a synthesizer. |labels| is a list of 1x88 matricies of one hot encodings of possible notes. Intervals is the number of microseconds between each encoding. returns Midi track. For now tempo is 60 bpm in all cases. """ # Default resolution 220. pattern = midi.Pattern(tick_relative=False) tempo_track = midi.Track(tick_relative=False) tempo_event = midi.SetTempoEvent(tick=0, bpm=60) tempo_track.append(tempo_event) pattern.append(tempo_track) note_track = midi.Track(tick_relative=False) pattern.append(note_track) # Hash set currently_on_notes = {} def recordChangeAtIndex(index, tick): midi_index = index + MIDI_OFFSET if currently_on_notes.get(index, False): event = midi.NoteOffEvent else: event = midi.NoteOnEvent note_track.append(event(tick=tick, pitch=midi_index, velocity=64)) currently_on_notes[index] = not currently_on_notes.get(index, False) def tickFromTime(time): # |time| in microseconds. ticks_per_sec = 220.0 ticks_per_microsecs = ticks_per_sec / 1000000 return int(ticks_per_microsecs * time) current_time = 0 for label in labels: current_time += interval for index, value in enumerate(label): if currently_on_notes.get(index, False) != value: recordChangeAtIndex(index, tickFromTime(current_time)) final_tick = note_track[-1].tick note_track.append(midi.EndOfTrackEvent(tick=final_tick)) tempo_track.append(midi.EndOfTrackEvent(tick=final_tick)) pattern.make_ticks_rel() return pattern
def generate_tempo_track(tempos,length): tick = generate_tick_seq(tempos['tick']['mat'],tempos['tick']['inds'],length) length = len(tick) mpqn = generate_markov_seq(tempos['mpqn']['mat'],tempos['mpqn']['inds'],length) track = midi.Track() track.append(midi.TrackNameEvent()) track.append(midi.TextMetaEvent()) for i in xrange(0,length): if mpqn[i]!=0: te = midi.SetTempoEvent() te.tick = tick[i] te.set_mpqn(mpqn[i]) track.append(te) track.append(midi.EndOfTrackEvent()) return track
def create_file_from_scalable(self, scalable_fname, tempo, num): scalable_pattern = midi.read_midifile(scalable_fname) new_pattern = midi.Pattern(format=0, resolution=96) new_track = midi.Track() new_pattern.append(new_track) new_track.append( midi.SetTempoEvent(tick=0, data=self.generate_array(tempo))) for event in scalable_pattern[0]: new_track.append(event) new_file_name = 'genre_' + self.genre_name + '_tempo_' + str( tempo) + "_file_" + str(self.remake_num) + '_' + str(num) + '.mid' midi.write_midifile(new_file_name, new_pattern) return new_file_name
def writeMid(note_time_list, bpm): ''' Usage: write the infomation got from wav transfer to a .mid file Args: note_time_list: the info from the note tranfer bpm: the bpm of the wav Returns: the pathName of the out midi file ''' # create a new midi.pattern, and add a track to it pattern = midi.Pattern() track = midi.Track() pattern.append(track) # change the bpm of midi file tempo = midi.SetTempoEvent(bpm=bpm) track.append(tempo) # transfer the note name in note_time_list to int value in midi format note_num_list = note_name2note_num(note_time_list) # transfer the note start_time and end_time to tick number in midi format start_end_tick_list = time2tick(note_time_list, bpm) #change the absolute tick to delta tick event_list = order_ticks(note_num_list, start_end_tick_list) # write the transformed list to noteOnEvents,add to the track for event in event_list: if event[2] == 1: on = midi.NoteOnEvent(tick=event[1], velocity=50, pitch=event[0]) track.append(on) else: off = midi.NoteOffEvent(tick=event[1], pitch=event[0]) track.append(off) # add endTrackEvent on the track eot = midi.EndOfTrackEvent(tick=1) track.append(eot) # Save the pattern to mid file with open('wav2mid.config', 'r') as configFile: outputPath = configFile.read() outMidPath = outputPath + str(uuid.uuid1()) + '.mid' midi.write_midifile(outMidPath, pattern) return outMidPath
def set_tempo_events(filename_in, filename_out, tempoevents): """ set midi tempo events """ midifile = midipy.read_midifile(filename_in) midifile.make_ticks_abs() max_tick = 0 for track in midifile: for event in track: if not isinstance(event, midipy.EndOfTrackEvent): max_tick = max(event.tick, max_tick) if isinstance(event, midipy.SetTempoEvent): track.remove(event) for track in midifile: for event in track: if isinstance(event, midipy.EndOfTrackEvent): event.tick = max_tick + 1 # TODO: adapt tempo for changing signatures # time_signatures = get_time_signature_events(filename_in) # # adaptions = [] # # for ts in time_signatures: # add = [ts.tick, 0, 4.0 / ts.denom] # adaptions.append(add) # # adaptions[-1][1] = tempoevents[-1].tick + 1 # # for row in adaptions: # for e in tempoevents: # if e.tick >= row[0] and e.tick < row[1]: # e.bpm = int(e.bpm * row[2]) for e in tempoevents: te = midipy.SetTempoEvent(tick=e.tick, bpm=e.bpm) midifile[0].append(te) for track in midifile: track.sort() midifile.make_ticks_rel() midipy.write_midifile(filename_out, midifile)
def generate_composition(number_of_tracks): head_of_file = [] pattern = midi.Pattern() t = midi.Track() note_choices = [2, 4, 8, 16] note_durations = [] for i in range(0, 54): note_durations.append(random.choice(note_choices)) for i in range(0, number_of_tracks): counter = 0 s = midi.read_midifile("theme_and_variations-{0}.midi".format(i)) for note in s[1][1:-1]: note.tick = note_durations[counter] counter += 1 midi.write_midifile("theme_and_variations-{0}.midi".format(i), s) for i in range(0, number_of_tracks): s = midi.read_midifile("theme_and_variations-{0}.midi".format(i)) if i == 0: head_of_file = s[0] del head_of_file[-1] head_of_file[2] = midi.SetTempoEvent(tick=0, data=[11, 113, 176]) head_of_file[0] = midi.TimeSignatureEvent(tick=0, data=[4, 2, 96, 8]) del s[1][-1] t.extend(s[1]) elif i == number_of_tracks - 1: del s[1][0] t.extend(s[1]) else: del s[1][-1] del s[1][0] t.extend(s[1]) os.remove("theme_and_variations-{0}.midi".format(i)) pattern.resolution = 32 pattern.format = 1 pattern.append(head_of_file) pattern.append(t) print pattern # Make file and move it to download directory to present to user midi.write_midifile("Theme-And-Variations.midi", pattern) print " DONE! "
def addtempoevent( self, tempo=120, absoluteticks=0 ): t = MIDI.SetTempoEvent( bpm = tempo ) t.absoluteticks = absoluteticks if len(self.tempos): if absoluteticks > self.tempos[-1].absoluteticks: self.tempos.append( t ) else: i = 0 while i < len(self.tempos): if absoluteticks < self.tempos[i].absoluteticks: self.tempos.insert(i, t) break elif absoluteticks == self.tempos[i].absoluteticks: self.tempos[i] = t break else: i += 1 else: self.tempos.append( t )
def main(): midifiles = glob.glob(params.lstm_output + '/*.csv') # Define midi pattern parameters pattern = midi.Pattern() pattern.resolution = 70 for midifile in midifiles: track = midi.Track() track.append(midi.SetTempoEvent(bpm = np.random.randint(10,20))) df = pd.read_csv(midifile, header=None) df = postprocess(df) # Decode output grid from LTSM into one full track of notes: track = decoder(track, df.values[:,0:]) eot = midi.EndOfTrackEvent(tick = 1) #essential for the track to be turned into a readable midi file track.append(eot) # Translate track into midi file pattern.append(track) midi.write_midifile(params.midi_generated + params.artist + ".mid", pattern)
def write_midi(self, midifile, resolution=1920, fillpitch=60): """ Discards any tempo transition, assumes the tempo at the beginning of the measure stays the same for the entire measure midifile: path of the midi file resolution: the ticks per second fillpitch: the pitch to be used to fill each measure """ import midi t = midi.Track() t.tick_relative = False sec2tick = lambda sec: int(sec * resolution) tempo = -1 now = 0 for i, measure in enumerate(self.measures): beat = self.index.measure2beat(i) assert (now - beat) < 0.0001, \ "now: {}, beat: {}, timesig: {}, prev: {}".format( now, beat, measure.timesig, self.measures[i - 1]) temponow = int(self.tempocurve(beat)) durbeats = measure.numbeats t.append(midi.TimeSignatureEvent(tick=sec2tick(now), numerator=measure.num, denominator=measure.den)) if temponow != tempo: tempo = temponow t.append(midi.SetTempoEvent(tick=sec2tick(now), bpm=tempo)) t.append(midi.NoteOnEvent(tick=sec2tick(now), pitch=fillpitch, velocity=1)) t.append(midi.NoteOffEvent(tick=sec2tick(now + durbeats), pitch=fillpitch, velocity=0)) now += durbeats t.append(midi.EndOfTrackEvent(tick=sec2tick(now) + 1)) midipattern = midi.Pattern([t], resolution=resolution) midipattern.tick_relative = False midipattern.make_ticks_rel() midi.write_midifile(midifile, midipattern) return midipattern
def statematrixToPattern(statematrix, bpm=120): pattern = midi.Pattern() track = midi.Track() pattern.append(track) tempo = midi.SetTempoEvent(tick=0) tempo.set_bpm(bpm) track.append(tempo) tickscale = 55 lastcmdtime = 0 prevstate = [0 for i in range(span * 2)] for time, state in enumerate(statematrix): offNotes = [] onNotes = [] for i in range(span): if prevstate[i] == 1: if state[i] == 0: offNotes.append(i) elif state[i + span] == 1: offNotes.append(i) onNotes.append(i) elif state[i] == 1: onNotes.append(i) for note in offNotes: track.append(midi.NoteOffEvent(tick=(time-lastcmdtime)*tickscale, pitch=note+lowerBound)) lastcmdtime = time for note in onNotes: track.append(midi.NoteOnEvent(tick=(time-lastcmdtime)*tickscale, velocity=40, pitch=note+lowerBound)) lastcmdtime = time prevstate = state eot = midi.EndOfTrackEvent(tick=1) track.append(eot) return pattern
def test_3(): print("[%s:%d] test_3()" % \ (os.path.basename(libs.thisfile()), libs.linenum() ), file=sys.stderr) # fname = "test.%s.mid" % (libs.get_TimeLabel_Now()) pitch_1 = midi.A_4 pitch_2 = midi.G_4 pitch_3 = midi.F_4 pitch_4 = midi.E_4 pitch_5 = midi.D_4 pitch_6 = midi.C_4 pitch_7 = midi.B_4 ps = [ midi.A_4, midi.G_4, midi.F_4, midi.E_4, midi.D_4, midi.C_4, midi.B_4, ] # ps = [pitch_1, pitch_2, pitch_3, pitch_4] lenOf_PS = len(ps) numOf_Notes = 32 # file name fname = "test.%s.ps-%02d.notes-%02d.mid" %\ (libs.get_TimeLabel_Now(), len(ps), numOf_Notes) pattern = midi.Pattern(resolution=960) #このパターンがmidiファイルに対応しています。 track = midi.Track() #トラックを作ります pattern.append(track) #パターンに作ったトラックを追加します。 ev = midi.SetTempoEvent(tick=0, bpm=120) #テンポを設定するイベントを作ります track.append(ev) #イベントをトラックに追加します。 '''################### set : notes ###################''' for i in range(numOf_Notes): # for i in range(8): num = rnd.randint(0, lenOf_PS - 1) # print("[%s:%d] num => %d" % \ # (os.path.basename(libs.thisfile()), libs.linenum() # , num # ), file=sys.stderr) # num = rnd.randint(1, lenOf_PS) e = midi.NoteOnEvent(tick=0, velocity=100, pitch=ps[num]) #ソの音を鳴らし始めるイベントを作ります。 track.append(e) e = midi.NoteOffEvent(tick=960, velocity=100, pitch=ps[num]) #ソの音を鳴らし終えるイベントを作ります。 track.append(e) # e = midi.NoteOnEvent(tick=0, velocity=100, pitch= pitch_1) #ソの音を鳴らし始めるイベントを作ります。 # track.append(e) # # e = midi.NoteOffEvent(tick=960, velocity=100, pitch= pitch_1) #ソの音を鳴らし終えるイベントを作ります。 # track.append(e) #/for i in range(8): '''################### track : end ###################''' eot = midi.EndOfTrackEvent(tick=1) #トラックを終えるイベントを作ります track.append(eot) midi.write_midifile(fname, pattern) #パターンをファイルに書き込みます。 '''###################
def change_music_to_pattern(music): music.parse_track_msg() # music._init_main_trank() pattern = midi.Pattern() pattern.resolution = music.get_resolution() pattern.format = music.get_play_format() for track in reversed(music.track): t = midi.Track() for event in track: event_tick = int(event[0]) event_event = event[1] state_code = event_event["state_code"] if state_code == 255: if event_event["name"] == 'Set Tempo': eve = midi.SetTempoEvent(tick=event_tick, bpm=event_event["bpm"]) elif event_event["name"] == 'Trank Name': eve = midi.TrackNameEvent(tick=event_tick, text=event_event["text"]) elif event_event["name"] == 'Copyright Notice': eve = midi.CopyrightMetaEvent(tick=event_tick, text=event_event["text"]) elif event_event["name"] == 'SMPTE Offset': eve = midi.SmpteOffsetEvent(tick=event_tick, text=event_event["text"]) elif event_event["name"] == 'Time Signature': eve = midi.TimeSignatureEvent( tick=event_tick, numerator=event_event["numerator"], denominator=event_event["denominator"], metronome=event_event["metronome"], thirtyseconds=event_event["thirtyseconds"]) elif event_event["name"] == "End of Track": eve = midi.EndOfTrackEvent(tick=event_tick) else: continue elif 240 <= state_code <= 254: # 系统码 eve = midi.SysexEvent() elif 224 <= state_code <= 239: # 滑音 eve = midi.PitchWheelEvent(tick=event_tick, channel=event_event["channel"], pitch=event_event["pitch"]) elif 208 <= state_code <= 223: # After Touch eve = midi.AfterTouchEvent() elif 192 <= state_code <= 207: # 乐器转换 eve = midi.ProgramChangeEvent(tick=event_tick, channel=event_event["channel"], data=[event_event["program"]]) elif 176 <= state_code <= 191: # midi控制器 eve = midi.ControlChangeEvent( tick=event_tick, channel=event_event["channel"], data=[event_event["control"], event_event["value"]]) elif 160 <= state_code <= 175: continue elif 144 <= state_code <= 159: # note on eve = midi.NoteOnEvent(tick=event_tick, channel=event_event["channel"], velocity=event_event["velocity"], pitch=event_event["pitch"]) elif 128 <= state_code <= 143: # note off eve = midi.NoteOffEvent(tick=event_tick, channel=event_event["channel"], velocity=event_event["velocity"], pitch=event_event["pitch"]) elif state_code <= 127: continue t.append(eve) pattern.append(t) return pattern
def numpy2midi(n): """Convert a numpy array n to a midi pattern in python-midi format, quantised etc.""" # print(n) # print(n.shape) resolution = 4 p = midi.Pattern(resolution=resolution) #, tick_relative=False) track = midi.Track() #track = midi.Track(tick_relative=False) p.append(track) set_tempo = midi.SetTempoEvent() set_tempo.set_bpm(120) set_tempo.set_mpqn(120) track_name = midi.TrackNameEvent(trackname="Track name") time_sig = midi.TimeSignatureEvent() time_sig.set_numerator(4) time_sig.set_denominator(4) time_sig.set_metronome(180) # time_sig.set_thirtyseconds(32) end = midi.EndOfTrackEvent() end.tick = nsteps * resolution #track.append(set_tempo) #track.append(track_name) #track.append(time_sig) for step in range(nsteps): tick = 0 for drum in range(len(names)): # print(n[drum, step]) if n[drum, step] > 0: on = midi.NoteOnEvent() on.channel = 9 on.pitch = dm2[drum] on.velocity = int(n[drum, step]) on.tick = tick track.append(on) # print(on) tick = 0 tick = resolution for drum in range(len(names)): if True: #elif step > 0 and n[drum, step-1] > 0: off = midi.NoteOffEvent() off.channel = 9 off.pitch = dm2[drum] off.velocity = 100 off.tick = tick track.append(off) # print(off) tick = 0 track.append(end) #p.make_ticks_rel() return p