def note_with_rhythm_pattern(self, rhythm, c=['C5', 'D5']): ''' A music clip note with rhythm ''' t = 0 c_len = len(c) for r in rhythm: note_number = pretty_midi.note_name_to_number(c[t]) note = pretty_midi.Note( velocity=20, pitch=note_number, start=r[0], end=r[1]) self.pm.instruments[0].notes.append(note) note_number = pretty_midi.note_name_to_number(c[t + 1]) note = pretty_midi.Note( velocity=30, pitch=note_number, start=r[0], end=r[1]) self.pm.instruments[0].notes.append(note) note_number = pretty_midi.note_name_to_number(c[t + 2]) note = pretty_midi.Note( velocity=20, pitch=note_number, start=r[0], end=r[1]) self.pm.instruments[0].notes.append(note) if (t + 6) >= c_len: break t += 3
def make_song(file,instr=0): res = 960 tempo = 120 pm = pretty_midi.PrettyMIDI(resolution=res, initial_tempo=tempo) #pretty_midiオブジェクトを作ります instrument = pretty_midi.Instrument(instr) #instrumentはトラックに相当します。 note = pretty_midi.Note(velocity=100, pitch=60, start=0, end=0.25) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=62, start=0.25, end=0.5) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=64, start=0.5, end=0.75) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=65, start=0.75, end=1) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=67, start=1, end=1.5) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=69, start=1.5, end=1.75) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=65, start=1.75, end=2) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=64, start=2, end=2.25) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=62, start=2.5, end=2.75) instrument.notes.append(note) note = pretty_midi.Note(velocity=100, pitch=60, start=3, end=4) instrument.notes.append(note) pm.instruments.append(instrument) pm.write(file) #midiファイルを書き込みます。
def rando_midi(filename): # Create a PrettyMIDI object cello_c_chord = pretty_midi.PrettyMIDI() # Create an Instrument instance for a cello instrument cello_program = pretty_midi.instrument_name_to_program('Cello') cello = pretty_midi.Instrument(program=cello_program) # Iterate over note names, which will be converted to note number later for note_name in ['F4', 'A5', 'C5']: # Retrieve the MIDI note number for this note name note_number = pretty_midi.note_name_to_number(note_name) # Create a Note instance for this note, starting at 0s and ending at .5s note = pretty_midi.Note(velocity=100, pitch=note_number, start=0, end=2) # Add it to our cello instrument cello.notes.append(note) for note_name in ['C5', 'E5', 'G5']: # Retrieve the MIDI note number for this note name note_number = pretty_midi.note_name_to_number(note_name) # Create a Note instance for this note, starting at 0s and ending at .5s note = pretty_midi.Note(velocity=100, pitch=note_number, start=2, end=4) # Add it to our cello instrument cello.notes.append(note) # Add the cello instrument to the PrettyMIDI object cello_c_chord.instruments.append(cello) # Write out the MIDI data cello_c_chord.write(filename)
def test_merge_midi(self): egp_chord = pretty_midi.PrettyMIDI() # egp_program = pretty_midi.instrument_name_to_program('Lead 2 (sawtooth)') egp_program = pretty_midi.instrument_name_to_program('Synth Bass 1') egp = pretty_midi.Instrument(program=egp_program) midi_data = pretty_midi.PrettyMIDI('180827_01_midi.mid') midi_data2 = pretty_midi.PrettyMIDI('180827_02_midi.mid') adding = midi_data.get_end_time() for instrument in midi_data.instruments: if not instrument.is_drum: for note in instrument.notes: # print(note.pitch, note.velocity, note.start, note.end) note = pretty_midi.Note(velocity=note.velocity, pitch=note.pitch, start=note.start, end=note.end) egp.notes.append(note) for instrument in midi_data2.instruments: if not instrument.is_drum: for note in instrument.notes: # print(note.pitch, note.velocity, note.start, note.end) note = pretty_midi.Note(velocity=note.velocity, pitch=note.pitch, start=note.start + adding, end=note.end + adding) egp.notes.append(note) egp_chord.instruments.append(egp) egp_chord.write('SynthBass1.mid')
def GVmidi(df, submidi, stdmidi, sub_name, std_name): new_out = df.iloc[:,4:8] new_notes1 = [] for row in new_out.iterrows(): new_notes1.append(pretty_midi.Note( velocity=int(row[1][3]), pitch=int(row[1][0]), start=row[1][1], end=row[1][2])) submidi.instruments[0].notes = new_notes1 new_notes2 = [] std_df = new_out = df.iloc[:,:4] for row in std_df.iterrows(): new_notes2.append(pretty_midi.Note( velocity=int(row[1][3]), pitch=int(row[1][0]), start=row[1][1], end=row[1][2])) stdmidi.instruments[0].notes = new_notes2 submidi.write(sub_name + '-m.midi') stdmidi.write(std_name + '-m.midi') loaded1 = Multitrack(sub_name + '-m.midi') loaded2 = Multitrack(std_name + '-m.midi') fig1, axs1 = loaded1.plot() fig2, axs2 = loaded2.plot() axs1[0].set_title('sub_mini') axs2[0].set_title('std_midi') # plt.show() fig1.savefig(sub_name + '.jpg') fig2.savefig(std_name + '.jpg') return new_notes1
def chord_to_instrument(chord_array, frame_per_bar=16): frame_per_second = (frame_per_bar / 4) * 2 unit_time = 1 / frame_per_second instrument = pretty_midi.Instrument(program=0, name='chord') chord = chord_array[0] prev_t = 0 for t in range(chord_array.shape[0]): if not (chord_array[t] == chord).all(): chord_notes = chord.nonzero()[0] for pitch in chord_notes: note = pretty_midi.Note(start=prev_t * unit_time, end=t * unit_time, pitch=48 + pitch, velocity=70) instrument.notes.append(note) prev_t = t chord = chord_array[t] chord_notes = chord.nonzero()[0] for pitch in chord_notes: note = pretty_midi.Note(start=prev_t * unit_time, end=chord_array.shape[0] * unit_time, pitch=48 + pitch, velocity=70) instrument.notes.append(note) return instrument
def run(): path = tkinter.filedialog.askopenfilename( title="Select file", filetypes=(("midi files", "*.mid"), ("all files", "*.*"))) insert_text('IN - ' + path) midi_data = pretty_midi.PrettyMIDI(path) for instrument in midi_data.instruments: if instrument.is_drum: continue temp_note = [] for note in instrument.notes: for pit in range(note.pitch-12, -1, -12): temp = pretty_midi.Note(velocity=note.velocity, pitch=pit, start=note.start, end=note.end) temp_note.append(temp) for pit in range(note.pitch+12, 128, 12): temp = pretty_midi.Note(velocity=note.velocity, pitch=pit, start=note.start, end=note.end) temp_note.append(temp) instrument.notes = instrument.notes + temp_note path = tkinter.filedialog.asksaveasfilename( title="Select file", filetypes=(("midi files", "*.mid"), ("all files", "*.*"))) midi_data.write(path) insert_text('OUT - ' + path) insert_text('Complete')
def resample(): chord, pr_mat, midi_in_path = get_select_sample() in_midi_notes = pretty_midi.PrettyMIDI(midi_in_path).instruments[0].notes out_midi = pretty_midi.PrettyMIDI() out_midi.instruments = [pretty_midi.Instrument(0)] for note in in_midi_notes: out_midi.instruments[0].notes.append( pretty_midi.Note(note.velocity, note.pitch, note.start * 4 / 3, min([note.end * 4 / 3, SAMPLE_LEN]))) for i in range(SAMPLE_LEN): out_midi.instruments[0].notes.append(pretty_midi.Note(1, 30, i, i + 1)) midi_path = 'static/uploads/{}.mid'.format( str(datetime.datetime.today()).replace("-", "").replace(" ", "").replace( ":", "").replace(".", "")) np.savez(midi_path[:-3] + 'npz', pr_mat=pr_mat, chord=chord) out_midi.write(midi_path) return { "midi": midi_path, "chords": chd_to_str(chord), "chd_mat": chord.tolist() }
def matrixToMidi(matrix, dest_file, onehot=True): # Create a PrettyMIDI object midi_obj = pretty_midi.PrettyMIDI() # Create an Instrument instance for a Piano instrument piano_program = pretty_midi.instrument_name_to_program( 'Acoustic Grand Piano') piano = pretty_midi.Instrument(program=piano_program) n_notes = matrix.shape[0] t = 0.0 if (onehot): note_matrix = [np.where(r == 1)[0][0] for r in matrix[:, 0:128]] print(note_matrix) for i in range(0, n_notes): p = note_matrix[i] s = t # Start = current time e = s + matrix[i, 128] #End = start + duration of note in seconds note = pretty_midi.Note(velocity=100, pitch=p, start=s, end=e) piano.notes.append(note) t = e #print(s) else: for i in range(0, n_notes): p = int(matrix[i, 0]) s = matrix[i, 2] + t # Start = rest before note + current time e = s + matrix[i, 1] # End = start + duration of note in seconds note = pretty_midi.Note(velocity=100, pitch=p, start=s, end=e) #print("pitch: %d start: %f , end: %f" % (p,s,e)) piano.notes.append(note) t = e midi_obj.instruments.append(piano) midi_obj.write(dest_file)
def chords(notes=None, root=None): import pretty_midi import numpy.random as rnd import os # sanitize some; root is MIDI integer, chord are relative notes to add. chord = tuple(map(int, notes.split(',')))[:16] root = int(root) pm = pretty_midi.PrettyMIDI(initial_tempo=80) inst = pretty_midi.Instrument(program=24, is_drum=False, name='') pm.instruments.append(inst) # root note, inst.notes.append(pretty_midi.Note(88, root, 0, 0.5)) # and chord components: for note in chord: inst.notes.append(pretty_midi.Note(88, root + note, 0, 0.8)) hF = '/tmp/gabor-{:x}'.format(rnd.randint(1000, 99999999)) pm.write('{}.mid'.format(hF)) os.system( 'timidity {0}.mid --output-mono -Ow -o - | ffmpeg -i - {0}.mp3'.format( hF)) os.unlink('{}.mid'.format(hF)) o = send_file('{}.mp3'.format(hF)) os.unlink('{}.mp3'.format(hF)) return o
def first_sampleC(): chord, pr_mat, midi_in_path = get_select_sample() in_midi_notes = pretty_midi.PrettyMIDI(midi_in_path).instruments[0].notes out_midi = pretty_midi.PrettyMIDI() out_midi.instruments = [pretty_midi.Instrument(0)] for note in in_midi_notes: out_midi.instruments[0].notes.append( pretty_midi.Note(note.velocity, note.pitch, note.start * 4 / 3, min([note.end * 4 / 3, SAMPLE_LEN]))) for i in range(SAMPLE_LEN): out_midi.instruments[0].notes.append(pretty_midi.Note(1, 30, i, i + 1)) midi_path = 'static/uploads/{}.mid'.format( str(datetime.datetime.today()).replace("-", "").replace(" ", "").replace( ":", "").replace(".", "")) np.savez(midi_path[:-3] + 'npz', pr_mat=pr_mat, chord=chord) out_midi.write(midi_path) send = {} send['midi_path'] = midi_path[7:] send['chords'] = chd_to_str(chord) send['chd_mat'] = chord.tolist() send['SAMPLE_LEN'] = SAMPLE_LEN send['CHORD_LEN_QUANT'] = CHORD_LEN_QUANT return render_template('indexC.html', send=send)
def generate_midi_segment_from_tensor(data, path): pm = pretty_midi.PrettyMIDI() instr_track = pretty_midi.Instrument(program=0, is_drum=False, name='Instr') quarter_length = 60 / 120 / 4 note_range = 84 time_step = 64 for note in range(note_range): during_note = False note_begin = 0 for time in range(time_step): has_note = data[time, note] >= 0.5 if has_note: if not during_note: during_note = True note_begin = time * quarter_length else: if time != time_step-1: continue else: note_end = time * quarter_length instr_track.notes.append(pretty_midi.Note(127, note + 24, note_begin, note_end)) during_note = False else: if not during_note: continue else: note_end = time * quarter_length instr_track.notes.append(pretty_midi.Note(127, note + 24, note_begin, note_end)) during_note = False pm.instruments.append(instr_track) pm.write(path)
def chords2midi(chords_dict, file_name): # pretty midiオブジェクトを作る piano_chord = pretty_midi.PrettyMIDI() # 楽器名を入れると、対応するgeneral midi program numberを返す piano_program = pretty_midi.instrument_name_to_program('Acoustic Grand Piano') # Instrument instanceをcelloとして作成 piano = pretty_midi.Instrument(program=piano_program) # 解析したコードを単音のリストにバラす for i, chord in enumerate(chords_dict["chords_result"]["chords"]): logger.info(i, chord) # Nの時はスキップ(ノートに書き込まない) if chord['chord'] == "N": continue chords_list = key2chord(chord) logger.info("chords list: {}".format(chords_list)) logger.info("start time: {}".format(chord["time"])) logger.info("end time: {}".format(chords_dict["chords_result"]["chords"][i+1]["time"]-0.1)) # print("time: {}".format(float(chords_dict["chords_result"]["chords"][i+1]["time"])-float(chord["time"]))) for note_name in chords_list: # コードの名前を数字に変換 note_number = pretty_midi.note_name_to_number(note_name) logger.info("chord name {0}, chord num {1}".format(note_name, note_number)) # velocityを定義する try: note = pretty_midi.Note( velocity=100, pitch=note_number, start=chord["time"], end=chords_dict["chords_result"] ["chords"][i+1]["time"]-0.1 ) # print(note) # 上記で作成したnoteをchelloインスタンスに加える piano.notes.append(note) except IndexError: # 最後の章は0.5秒とする logger.info("note last code") note = pretty_midi.Note( velocity=100, pitch=note_number, start=chord["time"], end=chord["time"]+0.5 ) # 上記で作成したnoteをchelloインスタンスに加える piano.notes.append(note) # PrettyMIDIオブジェクトに加える piano_chord.instruments.append(piano) print(piano) print(piano_chord) midi_file = "midi/" + str(file_name) + ".mid" # MIDIファイルとして書き出す piano_chord.write(midi_file) # Load MIDI file into PrettyMIDI object midi_data = pretty_midi.PrettyMIDI(midi_file) # Print an empirical estimate of its global tempo print(midi_data.estimate_tempo())
def build_midi_from_tensor(src_path, save_path, time_step=120, bar_length=4, valid_range=(24, 108)): data = build_single_tensor_from_sparse(src_path) piece_num = data.shape[0] instr_list = ['Drums', 'Piano', 'Guitar', 'Bass', 'Strings'] program_list = [0, 0, 24, 32, 48] pm = pretty_midi.PrettyMIDI() for i in range(5): instr = instr_list[i] is_drum = (instr == 'Drums') instr_track = pretty_midi.Instrument(program_list[i], is_drum=is_drum, name=instr) track_data = data[:, :, :, :, i] for piece in range(piece_num): for bar in range(bar_length): init_time = piece * (bar_length * time_step) + bar * time_step print(init_time) for note in range(valid_range[1] - valid_range[0]): during_note = False note_begin = init_time for time in range(time_step): has_note = track_data[piece, bar, time, note] if has_note: if not during_note: during_note = True note_begin = time + init_time else: if time != time_step - 1: continue else: note_end = time + init_time print(note_begin / 60, note_end / 60) instr_track.notes.append( pretty_midi.Note( 64, note + 12, note_begin / 48, note_end / 48)) else: if not during_note: continue else: note_end = time + init_time print(note_begin / 60, note_end / 60) instr_track.notes.append( pretty_midi.Note(64, note + 12, note_begin / 48, note_end / 48)) during_note = False pm.instruments.append(instr_track) pm.write(save_path)
def create_midi_from_piece(piece: Piece, midi_path: str, measure_in_seconds: float, instruments: List[int], velocity: int, opening_silence_in_seconds: float = 1.0, trailing_silence_in_seconds: float = 1.0) -> None: """ Create MIDI file from a piece created by this package. :param piece: musical piece :param midi_path: path where resulting MIDI file is going to be saved :param measure_in_seconds: duration of one measure in seconds :param instruments: IDs of instruments (according to General MIDI specification) that play corresponding melodic lines :param velocity: one common velocity for all notes :param opening_silence_in_seconds: number of seconds with silence to add at the start of the composition :param trailing_silence_in_seconds: number of seconds with silence to add at the end of the composition :return: None """ numeration_shift = pretty_midi.note_name_to_number('A0') pretty_midi_instruments = [] for melodic_line, instrument in zip(piece.melodic_lines, instruments): pretty_midi_instrument = pretty_midi.Instrument(program=instrument) for element in melodic_line: start_time = element.start_time * measure_in_seconds start_time += opening_silence_in_seconds end_time = start_time + element.duration * measure_in_seconds pitch = element.position_in_semitones + numeration_shift note = pretty_midi.Note(start=start_time, end=end_time, pitch=pitch, velocity=velocity) pretty_midi_instrument.notes.append(note) pretty_midi_instrument.notes.sort(key=lambda x: (x.start, x.pitch)) pretty_midi_instruments.append(pretty_midi_instrument) trailing_silence_start = piece.n_measures * measure_in_seconds trailing_silence_start += opening_silence_in_seconds note = pretty_midi.Note( velocity=0, pitch=1, # Arbitrary value that affects nothing. start=trailing_silence_start, end=trailing_silence_start + trailing_silence_in_seconds) pretty_midi_instruments[0].notes.append(note) composition = pretty_midi.PrettyMIDI() for pretty_midi_instrument in pretty_midi_instruments: composition.instruments.append(pretty_midi_instrument) composition.write(midi_path)
def crop_by_measure(self): cropped_pm = [] for measure in range(self.measures_num): pm = pretty_midi.PrettyMIDI() piano = pretty_midi.Instrument(program=0) for instr in self.pm.instruments: for note in instr.notes: pitch = note.pitch velocity = note.velocity start_time, end_time = note.start, note.end start_measure, end_measure = int(start_time // 2), int( end_time // 2) if start_measure > measure or end_measure < measure: continue else: if start_measure == end_measure == measure: new_start, new_end = start_time - measure * 2.0, end_time - measure * 2.0 new_note = pretty_midi.Note(velocity=velocity, pitch=pitch, start=new_start, end=new_end) piano.notes.append(new_note) elif start_measure == measure < end_measure: new_start, new_end = start_time - measure * 2.0, 2.0 new_note = pretty_midi.Note(velocity=velocity, pitch=pitch, start=new_start, end=new_end) piano.notes.append(new_note) elif start_measure < measure == measure: new_start, new_end = 0, end_time - measure * 2.0 new_note = pretty_midi.Note(velocity=velocity, pitch=pitch, start=new_start, end=new_end) piano.notes.append(new_note) else: assert start_measure < measure < end_measure new_start, new_end = 0, 2.0 new_note = pretty_midi.Note(velocity=velocity, pitch=pitch, start=new_start, end=new_end) piano.notes.append(new_note) pm.instruments.append(piano) cropped_pm.append(pm) return cropped_pm
def skyline_for_instrument(self, instrument): ''' Apply skyline algorithm to an instrument. Arg: - instrument: A `pretty_midi.Instrument` object. Return: - skyline_instrument: A `pretty_midi.Instrument` object with melody extracted by skyline algorithm. ''' skyline_instrument = copy.deepcopy(instrument) notes = skyline_instrument.notes n_notes = len(notes) # number of notes # when the length is too short, don't process it if n_notes < 2: return skyline_instrument # make sure all the notes are sorted by start time notes.sort(key=lambda note: note.start) # start skyline algorithm k = j = 0 while j < n_notes - 1: k = j + 1 # handle the situation where note_j and note_k have a same pitch while (k <= n_notes - 1) and (notes[j].start == notes[k].start): if notes[j].pitch < notes[k].pitch: # label note_j's start point -1 for later process notes[j] = pretty_midi.Note( notes[j].velocity, notes[j].pitch, -1, notes[j].end) j = k k += 1 else: # label note_k's start point -1 for later process notes[k] = pretty_midi.Note( notes[k].velocity, notes[k].pitch, -1, notes[k].end) k += 1 if k > n_notes - 1: break # handle the situation where note_j comes before note_k if notes[j].end > notes[k].start: notes[j] = pretty_midi.Note(notes[j].velocity, notes[j].pitch, notes[j].start, notes[k].start) j = k # eliminate all the notes whose start points are -1 notes = [note for note in notes if note.start != -1] skyline_instrument.notes = notes return skyline_instrument
def make_midi(dict_note, pred_argmax, x_num, y_num, TEMPO, NUMERATOR, DENOMINATOR, path_output_melody_chords_midi): def calc_notetime(tempo, numerator, denominator): notetime = [0] * 10 j = 64 for i in range(9): notetime[i + 1] = 60 * numerator * (1 / j) / tempo j /= 2 return notetime # 音を鳴らす間隔(nt[5]は4分音符) nt = calc_notetime(TEMPO, NUMERATOR, DENOMINATOR) pm = pretty_midi.PrettyMIDI(resolution=960, initial_tempo=TEMPO) instrument = pretty_midi.Instrument( program=89, is_drum=False) # 89:synth pad(fantasia) # melody time = 0 for i in range(x_num): for j in range(y_num): note_name = dict_note[str(i) + str(j)][0] note_number = pretty_midi.note_name_to_number(note_name) d_time = nt[int(math.log2(64 * dict_note[str(i) + str(j)][1]))] # if dict_note[str(i)+str(j)][1] =0.5, # d_time = nt[5] note = pretty_midi.Note(velocity=100, pitch=note_number, start=time, end=time + d_time) instrument.notes.append(note) time = time + d_time # chords time = 0 for chord_num in pred_argmax[0]: note_names = chords_li[chord_num] d_time = nt[7] # 全音符 for note_name in note_names: note_number = pretty_midi.note_name_to_number(note_name) note = pretty_midi.Note(velocity=100, pitch=note_number, start=time, end=time + d_time) instrument.notes.append(note) time = time + d_time pm.instruments.append(instrument) pm.write(path_output_melody_chords_midi) print('') print('FInish generating MIDI file (melody+chord) .')
def test_two_notes_plot(self): plotter = Plotter() pretty_midi = pm.PrettyMIDI() pretty_midi.instruments.append(pm.Instrument(0)) notes = [pm.Note(100, 36, 1.5, 1.7), pm.Note(100, 37, 3.5, 4.0)] [pretty_midi.instruments[0].notes.append(note) for note in notes] plotter.plot(pretty_midi) output_file = os.path.join("output", "test_two_notes_plot.html") plotter.save(pretty_midi, output_file)
def inference(pred, beat_th=0.5, down_beat_th=0.5, min_dist=0.3, t_unit=0.1): """Infers the beat and down beat positions from the raw prediction values. Parameters ---------- pred: 2D numpy array The prediction of the model. beat_th: float Threshold for beat channel. down_beat_th: float Threshold for down beat channel. min_dist: float Minimum distance between two beat positions in seconds. t_unit: float Time unit of each frame in seconds. Returns ------- midi: pretty_midi.PrettyMIDI Inferred beat positions recorded as MIDI notes. Information of beat and down beat are recorded in two different instrument tracks. """ mdist = max(1, round(min_dist / t_unit)) beat_pos, _ = find_peaks(pred[:, 0], height=beat_th, distance=mdist) db_pos, _ = find_peaks(pred[:, 1], height=down_beat_th, distance=mdist) beat_notes = [] for pos in beat_pos: start_time = pos * t_unit end_time = start_time + 0.5 beat_notes.append( pretty_midi.Note(start=start_time, end=end_time, pitch=BEAT_NOTE_NUM, velocity=100)) db_notes = [] for pos in db_pos: start_time = pos * t_unit end_time = start_time + 0.5 db_notes.append( pretty_midi.Note(start=start_time, end=end_time, pitch=DOWN_BEAT_NOTE_NUM, velocity=100)) beat_inst = pretty_midi.Instrument(is_drum=True, program=0, name="Beat") beat_inst.notes += beat_notes db_inst = pretty_midi.Instrument(is_drum=True, program=0, name="Down Beat") db_inst.notes += db_notes midi = pretty_midi.PrettyMIDI() midi.instruments = [beat_inst, db_inst] return midi
def seq2piano(seq): ''' Convert a sequence of events to midi :param seq: numpy array that contains the sequence :return: midi object ''' midi = pretty_midi.PrettyMIDI() piano = pretty_midi.Instrument(program=0, is_drum=False, name='piano') midi.instruments.append(piano) if seq.ndim > 1: seq = np.argmax(seq, axis=-1) inote = {} velo = 40 time = 0. for e in seq: t, v = Event.decode(e) if t == 'shift': time += v elif t == 'velo': velo = v for n in inote.values(): if n[2] == time: n[0] = v elif t == 'down': n = inote.get(v, None) if n is not None: logging.debug( 'consecutive downs for pitch %d at time %d and %d' % (v, n[2], time)) else: inote[v] = [velo, v, time, -1] else: n = inote.get(v, None) if n is not None: n[-1] = time if n[-1] > n[-2]: piano.notes.append(pretty_midi.Note(*n)) else: logging.debug( 'note with non-positive duration for pitch %d at time %d' % (n[1], n[2])) del inote[v] else: logging.debug('up without down for pitch %d at time %d' % (v, time)) # clean out the incomplete note buffer, assuming these note end at last for n in inote.values(): n[-1] = time if n[-1] > n[-2]: piano.notes.append(pretty_midi.Note(*n)) return midi
def music_generation(self,input_values,actual_values,duration,velocity_values,start_time, file_name): ''' Parameters: - input_values (list) : - actual_values (torch.Tensor) : - duration (torch.Tensor) : - velocity_values (list) : - start_time (list): - file_name (string): Returns: - None ''' final_list=[] final_end_time_list=[] counter=0 #print(len(actual_values)) for i in range(len(input_values)): if(i==0): note=pretty_midi.Note(pitch=int(input_values[i]),velocity=int(velocity_values[i]),start=start_time[i],end=start_time[i]+duration[i]) self.cello.notes.append(note) final_list.append(note) note=pretty_midi.Note(pitch=int(actual_values[counter]),velocity=int(velocity_values[i]),start=start_time[i],end=start_time[i]+duration[i]) final_end_time_list.append(start_time[i]+duration[i]) self.cello.notes.append(note) final_list.append(note) else: if((start_time[i]-final_end_time_list[counter])>=0): counter+=1 note=pretty_midi.Note(pitch=int(input_values[i]),velocity=int(velocity_values[i]),start=start_time[i],end=start_time[i]+duration[i]) self.cello.notes.append(note) final_list.append(note) note=pretty_midi.Note(pitch=int(actual_values[counter]),velocity=int(velocity_values[i]),start=start_time[i],end=start_time[i]+duration[i]) self.cello.notes.append(note) final_list.append(note) final_end_time_list.append(start_time[i]+duration[i]) else: note=pretty_midi.Note(pitch=int(input_values[i]),velocity=int(velocity_values[i]),start=start_time[i],end=start_time[i]+duration[i]) self.cello.notes.append(note) final_list.append(note) self.cello_c_chord.instruments.append(self.cello) # Write out the MIDI data # print(counter) print(final_list) self.cello_c_chord.write('output/{}.mid'.format(file_name))
def create_notes(velocity=100): notes = [] notes.append( pretty_midi.Note(velocity=velocity, pitch=70, start=0.0, end=1.0)) notes.append( pretty_midi.Note(velocity=velocity, pitch=80, start=1.0, end=2.0)) notes.append( pretty_midi.Note(velocity=velocity, pitch=75, start=1.5, end=2.5)) notes.append( pretty_midi.Note(velocity=velocity, pitch=60, start=5.1, end=5.34)) return notes
def CodeToBass(self): bpm = self.bpm code_ls = self.code_ls beat = 60/bpm inst_pm_num = pretty_midi.instrument_name_to_program("Electric Bass (finger)") track = pretty_midi.Instrument(program=inst_pm_num) now = self.rug def Octave(note): if note in ["C","C#","D","D#","E","F"]: return 3 else: return 2 root1 = self.note_num_dic[self.code1[0]] + 12*Octave(self.code1[0]) root4 = self.note_num_dic[self.code4[0]] + 12*Octave(self.code4[0]) root5 = self.note_num_dic[self.code5[0]] + 12*Octave(self.code5[0]) now = self.rug root = root1 for i in range(len(code_ls)): code = code_ls[i] #休符の時 if code == "N": #直前にコードが存在すれば1拍ならす if i >= 1 and code_ls[i-1] in ["code1","code4","code5"]: note = pretty_midi.Note(velocity = 100,pitch = root, start=now, end=now+beat*2) track.notes.append(note) now += beat*2 #休符にする場合 else: now += beat*2 #コードが存在するとき else: if code == "code1": root = root1 elif code == "code4": root = root4 elif code == "code5": root = root5 for i in range(4): note = pretty_midi.Note(velocity = 100,pitch = root, start=now, end=now+beat/2) track.notes.append(note) now += beat/2 return track
def CodeToPiano(self): bpm = self.bpm code_ls = self.code_ls beat = 60/bpm self.code1_num = self.CodeNumber(self.code1) self.code4_num = self.CodeNumber(self.code4) self.code5_num = self.CodeNumber(self.code5) inst_pm_num = pretty_midi.instrument_name_to_program("Acoustic Grand Piano") track = pretty_midi.Instrument(program=inst_pm_num) now = self.rug #本体 codenum = self.code1_num for i in range(len(code_ls)): code = code_ls[i] #休符の時 if code == "N": #直前にコードが存在すれば2拍ならす #codenumは直前のものが残る if i >= 1 and code_ls[i-1] in ["code1","code4","code5"]: for j in range(3): note = pretty_midi.Note(velocity = 100,pitch = codenum[j],start=now,end=now+beat*2) track.notes.append(note) now += beat*2 #休符にする場合 else: now += beat* 2 #コードが存在するとき else: if code == "code1": codenum = self.code1_num elif code == "code4": codenum = self.code4_num elif code == "code5": codenum = self.code5_num #三種の音×2回 for i in range(2): for j in range(3): note = pretty_midi.Note(velocity = 100,pitch = codenum[j],start=now,end=now+beat) track.notes.append(note) now += beat return track
def save_as_midi(song, path="", name="default.mid", BPM = 120, velocity = 100): pm = pretty_midi.PrettyMIDI(resolution=960, initial_tempo=BPM) #pretty_midiオブジェクトを作ります instrument = pretty_midi.Instrument(0) #instrumentはトラックみたいなものです。 for i,tones in enumerate(song): which_tone = torch.nonzero((tones == 1), as_tuple=False).reshape(-1) if len(which_tone) == 0: note = pretty_midi.Note(velocity=0, pitch=0, start=i, end=i+1) #noteはNoteOnEventとNoteOffEventに相当します。 instrument.notes.append(note) else: for which in which_tone: note = pretty_midi.Note(velocity=velocity, pitch=int(which), start=i, end=i+1) #noteはNoteOnEventとNoteOffEventに相当します。 instrument.notes.append(note) pm.instruments.append(instrument) pm.write(os.path.join(path, name)) #midiファイルを書き込みます。
def test_4(): print("[%s:%d] test_4()" % \ (os.path.basename(libs.thisfile()), libs.linenum() ), file=sys.stderr) # Create a PrettyMIDI object cello_c_chord = pretty_midi.PrettyMIDI() # Create an Instrument instance for a cello instrument cello_program = pretty_midi.instrument_name_to_program('Cello') cello = pretty_midi.Instrument(program=cello_program) # Iterate over note names, which will be converted to note number later for note_name in ['C5', 'E5', 'G5']: # Retrieve the MIDI note number for this note name note_number = pretty_midi.note_name_to_number(note_name) # Create a Note instance for this note, starting at 0s and ending at .5s note = pretty_midi.Note(velocity=100, pitch=note_number, start=0, end=.5) # Add it to our cello instrument cello.notes.append(note) # Add the cello instrument to the PrettyMIDI object cello_c_chord.instruments.append(cello) # Write out the MIDI data cello_c_chord.write('cello-C-chord.mid')
def create_scale(duration, silence, velocity, start=0): """ Returns a list of notes in scale from 21 to 108 included. Arguments --------- duration : float the duration of each note in seconds silence : float the duration of the silence in between two notes velocity : int the velocity of each note start : float the start time of the scale in seconds Returns ------- list : list of pretty_midi.Note float : the end of the scale in seconds """ scale = [] for i in range(21, 109): end = start + duration scale.append(pm.Note(velocity, i, start, end)) start = end + silence return scale, end + silence
def melody_matrix2data(melody_matrix, tempo=120, start_time=0.0, get_list=False): ROLL_SIZE = 130 HOLD_PITCH = 128 REST_PITCH = 129 melodyMatrix = melody_matrix[:, :ROLL_SIZE] melodySequence = [np.argmax(melodyMatrix[i]) for i in range(melodyMatrix.shape[0])] melody_notes = [] minStep = 60 / tempo / 4 onset_or_rest = [i for i in range(len(melodySequence)) if not melodySequence[i] == HOLD_PITCH] onset_or_rest.append(len(melodySequence)) for idx, onset in enumerate(onset_or_rest[:-1]): if melodySequence[onset] == REST_PITCH: continue else: pitch = melodySequence[onset] start = onset * minStep end = onset_or_rest[idx + 1] * minStep noteRecon = pyd.Note(velocity=100, pitch=pitch, start=start_time + start, end=start_time + end) melody_notes.append(noteRecon) if get_list: return melody_notes else: melody = pyd.Instrument(program=pyd.instrument_name_to_program('Acoustic Grand Piano')) melody.notes = melody_notes return melody
def save(self, file_path, note_df): ''' Save MIDI file. Args: file_path: File path of MIDI. note_df: `pd.DataFrame` of note data. ''' chord = pretty_midi.PrettyMIDI() for program in note_df.program.drop_duplicates().values.tolist(): df = note_df[note_df.program == program] midi_obj = pretty_midi.Instrument(program=program) for i in range(df.shape[0]): note = pretty_midi.Note( velocity=int(df.iloc[i, :]["velocity"]), pitch=int(df.iloc[i, :]["pitch"]), start=float(df.iloc[i, :]["start"]), end=float(df.iloc[i, :]["end"]) ) # Add it to our cello instrument midi_obj.notes.append(note) # Add the cello instrument to the PrettyMIDI object chord.instruments.append(midi_obj) # Write out the MIDI data chord.write(file_path)