def convert(file):
#Load the MIDI file and parse it into CSV format
csv_string = pm.midi_to_csv(filepathin + "\\\\" + file)
# load the data in csv
str1 = ''.join(csv_string)
array = []
array1 = []
array2 = [] # all the info in midi
csv_array = [] # final array
array = str1.split('\n')
for item in array:
array1 = item.split(', ')
array2.append(array1)
#print(array2)
for row in array2:
row[1] = int(row[1])
if row[2] == 'Time_signature': # time and time signature
row[3] = int(row[3])
row[4] = int(row[4])
csv_array.append([row[1], row[3] * 300 + pow(2, row[4])])
elif row[2] == 'Tempo': # time and tempo
row[3] = int(row[3])
csv_array.append([row[1], row[3]])
elif row[2] == 'Note_on_c':
row[4] = int(row[4])
csv_array.append([row[1], row[4]])
#print(csv_array)
with open(csvpath + "\\\\" + file + '.csv', 'w', newline="") as out:
for row in csv_array:
writer = csv.writer(out)
writer.writerow(row)
def process_midi(midiFile):
if isinstance(midiFile, str):
filename = midiFile.rsplit("/", 1)[-1]
else:
filename = midiFile.filename
filename = filename.rsplit(".", 1)
title = filename[0]
extension = filename[1].lower() if 1 < len(filename) else ""
if extension not in ["mid", "midi", "kar"]:
raise ValueError("Oops! Your file seems to have the wrong extension!")
try:
csv = midi_to_csv(midiFile)
except Exception:
raise ValueError("Oh no! There was a problem processing your MIDI file!")
song = Song(title)
tempo_map = TempoMap()
rows = "".join(csv).splitlines()
for i, row in enumerate(rows):
cells = row.split(", ")
event = cells[2]
if event == "Header":
tempo_map.ticks_per_quarter_note = int(cells[5])
elif event == "Title_t" and (track := int(cells[0])) == 1:
song.title = cells[3][1:-1]
elif event == "Tempo":
tick = int(cells[1])
tempo = int(cells[3])
tempo_map.add_tempo(tick, tempo)
def main():
midiName = 'Despacito_Piano_Sheet_Music_Luis_Fonsi_ft_Daddy_Yankee.mid'
midiLocation = './' + midiName
csv_string = py_midicsv.midi_to_csv(midiLocation)
# Mutate all the elements in csv_string
for ind, line in enumerate(csv_string):
line.strip('\n')
csv_string[ind] = list(map(convertIfInt, line.split(',')))
csv_string.sort(key=lambda x: x[1])
csv_string = filter(lambda x: 'Note' in x[2], csv_string)
partition = 0
while True:
with open(midiName[:-4] + str(partition) + '.csv.txt', 'w') as csvfile:
csvfile.write('')
for dummy in range(1500):
try:
csvfile.write(str(next(csv_string)) + '\n')
except:
csvfile.write('[\'EOF\']')
return
csvfile.write('[\'EOF\']')
partition += 1
def midi_json(output):
maintain = []
notes = []
csv_string = py_midicsv.midi_to_csv(output)
for idx in range(len(csv_string)):
current = (csv_string[idx]).strip().split(',')
if 'Note' not in current[2]:
continue
current[4] = int(current[4]) % 12
if 'on' in current[2]:
maintain.append([current[4], float(int(current[1])/100)])
if 'off' in current[2]:
for idx,note in enumerate(maintain):
if note[0] == current[4]:
d = {}
d["pitch"] = current[4]
d["start"] = note[1]
d["end"] = float(int(current[1])/100)
notes.append(d)
del maintain[idx]
break
final = {}
note = {}
note["id"] = output
note["notes"] = notes
final["notes"] = note
return final
def generate_data(filename):
csv_string = pm.midi_to_csv(filename)
notes = np.zeros((60000, 96))
last = 0
start = False
start_time = 0
for x in csv_string:
note = x.split(',')
if note[2] == ' Note_on_c':
if not start:
start_time = int(note[1]) // 60
start = True
time = int(note[1]) // 60 - start_time
pitch = int(note[4]) - 16
if pitch <= 0:
print("ERROR")
notes[time, pitch] = 1
last = time
notes = np.resize(notes, (last, 96))
data = np.zeros((0, 48, 96))
for i in range(0, notes.shape[0] - 47, 40):
if np.sum(notes[i:i + 48, :]) > 15:
data = np.append(data,
np.expand_dims(notes[i:i + 48, :], axis=0),
axis=0)
return data
def __init__(self, midi_filepath, audio_filepath):
self.midi_csv_strings = pm.midi_to_csv(midi_filepath)
self.meta_data = self.midi_csv_strings[0:7]
self.track_end = self.midi_csv_strings[-2:]
self.midi_data = self.midi_csv_strings[5:-2]
header = self.meta_data[0].split(',')
tempo = self.meta_data[2].split(',')
ticks_per_quarter = 384
microsec_per_quarter = 500000
microsec_per_tick = microsec_per_quarter / ticks_per_quarter
seconds_per_tick = microsec_per_tick / 1000000
self.tempo = microsec_per_quarter
self.PPQ = ticks_per_quarter
self.song_total_midi_ticks = int(self.track_end[0].split(', ')[1])
self.midi_note_array = np.zeros((128, self.song_total_midi_ticks))
self.midi_sus_array = np.zeros((1, self.song_total_midi_ticks))
self.downsampled_tempo = None
self.midi_array_splits = None
self.audio_waveform, self.sample_rate = librosa.load(audio_filepath,
sr=None)
self.raw_spectrogram = librosa.stft(self.audio_waveform)
self.db_spectrogram = np.flipud(
librosa.amplitude_to_db(abs(self.raw_spectrogram)))
self.song_total_sample_ticks = self.db_spectrogram.shape[0]
self.spectrogram_array_splits = None
self.mel_spectrogram = None
self.mel_windows = None
self.midi_windows = None
self.midi_slices = None
def convert_midi_to_csv(midi_path, csv_path, write_midi_cvs_to_file=False):
# convert_midi_to_csv: Retrieves MIDI files at a folder and creates the corresponding csv converted files.
# It uses py_midicsv, to obtain a csv type MIDI event file. Then it uses the midi_to_nmat to obtain a note
# matrix representation of the notes. The note matrix representation is saved as a csv file.
files_list = os.listdir(os.path.join(midi_path))
for file_name in files_list:
if file_name[-3:] == 'mid':
print("Converting:" + file_name + "...", end="")
midi_file_path = os.path.join(midi_path, file_name)
csv_file_path = os.path.join(csv_path, file_name[:-3]+"csv")
midi_csv_list = py_midicsv.midi_to_csv(midi_file_path)
nmat = midi_to_nmat(midi_csv_list)# midi_csv to nmat_csv
with open(csv_file_path, 'w', newline='') as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_NONE)
wr.writerows(nmat)
myfile.close
if write_midi_cvs_to_file:
midi_csv_file_path = os.path.join(csv_path, folder, file_name[:-4] + "_MIDI.csv")
csvfile = open(midi_csv_file_path,'w')
csvfile.writelines(midi_csv_list)
csvfile.close()
print("Done!")
def all_midi_in_path_to_csv(self, midi_folder_path):
now = datetime.datetime.now()
current_timestamp = now.strftime("%Y-%m-%d %H:%M")
destination_path = "CSVs%d" % current_timestamp
# Create the new folder
try:
os.mkdir(destination_path)
except OSError:
print("Creation of the directory %s failed" % destination_path)
else:
print("Successfully created the directory %s " % destination_path)
# Here iterate through folder and use midi_to_csv on each
directory = os.fsencode(midi_folder_path)
for file in os.listdir(directory):
filename = os.fsdecode(file)
if filename.endswith(".mid") or filename.endswith(".midi"):
new_csv = midicsv.midi_to_csv(filename)
save_name = destination_path + "/" + "weewee_%d.csv" % current_timestamp
new_file_name = os.path.join(os.path.expanduser('~'),
midi_folder_path, save_name)
f = open(new_file_name, "x")
f.write(new_csv)
continue
else:
continue
def midi_to_csv(self, midi_path):
file = os.fsencode(midi_path)
filename = os.fsdecode(file)
if filename.endswith(".mid") or filename.endswith(".midi"):
csv = midicsv.midi_to_csv(filename)
# lets write all of these to a new directory
return csv
def miditotxt(direc):
csvText = py_midicsv.midi_to_csv(direc)
outDirec = direc.split("\\")
outval = outDirec[-1][0:-4]
CreateText = open(outval + ".txt", 'w')
for i in csvText:
CreateText.write(i)
CreateText.close()
def load_to_csv(filepath):
"""
Load midi to csv.
:param filepath:
:return:
"""
s = midi.midi_to_csv(filepath)
return s
def midi_csv(filename):
csv_string = py_midicsv.midi_to_csv(filename)
count = 0
for i in csv_string:
line = i.strip().split(", ")
if line[2] == 'Note_on_c' or line[2] == 'Note_off_c':
count += 1
return csv_string, count
def RecMidiChatty(direc, outdirec):
'''Give me a directory, I'll convert all the midi files into csv's, and put them into the outdirec!
(I'll do my best to make it an exact copy, inner folders and all)
This is also the Chatty version! I'll be printing out a bunch of stuff. If you don't want that just do RecMidi.'''
listostuff = os.listdir(direc)
print(listostuff)
path_to_dir = (outdirec)
garbage = []
try:
os.mkdir((path_to_dir))
except (FileExistsError):
print("file already exists")
converts = 0
for j in listostuff:
currDir = direc + "\\" + j
#(If this is another directory, do it again)
if (os.path.isdir(currDir) and (j != ".git")):
print(currDir)
converts += RecMidiChatty(currDir, (path_to_dir + "\\" + j))
elif (j[-4:] != '.mid'):
continue
else:
print(j)
try:
csvText = pym.midi_to_csv(currDir)
except (TypeError):
print("ERROR ERROR ERROR\nType Error! " + j +
" won't be converted! File just sucks probably.")
continue
except:
print("ERROR ERROR ERROR\n Something went wrong! " + j +
" won't be converted!!!!!")
continue
mani = j[:-4]
mani += ".txt"
CreateText = open(direc + "\\" + mani, 'w+')
for i in csvText:
try:
CreateText.write(i)
except:
print(
"ERROR\n Something went wrong when writing. Adding to the pile..."
)
CreateText.close()
garbage.append(path_to_dir + "\\" + mani)
break
CreateText.close()
path_to_curr = direc + "\\" + mani
try:
sh.move(path_to_curr, path_to_dir)
except:
renameVal = path_to_curr[:-4] + str(converts) + ".txt"
os.rename(path_to_curr, renameVal)
sh.move(renameVal, path_to_dir)
converts += 1
for i in garbage:
os.remove(i)
return converts
def midi_to_csv(midi_filename: str) -> pd.DataFrame:
csv_string = py_midicsv.midi_to_csv(midi_filename)
data = []
for row in csv_string:
row = row.replace('\n', '')
row = row.split(', ')
data += [row]
return pd.DataFrame(data)
def midi2list(path):
str_list = pm.midi_to_csv(path)
for i in range(len(str_list)):
str_list[i] = (str_list[i].replace(' ', '').replace('\n',
'')).split(',')
for j in range(len(str_list[i])):
if str_list[i][j].isdigit():
str_list[i][j] = int(str_list[i][j])
return str_list
def midi_to_df(midi_file, save=False):
"""Converts a midi file to a list of csv then to a pandas df.
Parameters
----------
midi_file : str
The directory pointing towards the midi file to be converted.
save : bool, optional
If specified, saves `midi_file` as a csv in the same directory
and as the same name.
Returns
-------
pandas.DataFrame
A DataFrame that contains the timing of note events and note values,
amongst other (irrelevant) information.
Raises
------
ValueError
If `midi_file` is not pointing towards a .mid file.
"""
if midi_file[-4:] != ".mid":
raise ValueError("Pass in a .mid file!")
csv_string = py_midicsv.midi_to_csv(midi_file)
df = pd.DataFrame([ls.strip().split(",") for ls in csv_string])
# strip all whitespaces
df[2] = df[2].str.strip()
df[4] = df[4].str.strip()
# convert values to int
for col in [0, 1, 4, 5]:
df[col] = df[col].apply(pd.to_numeric, errors="coerce")
df[col] = df[col].fillna(0).astype(int)
# convert note velocity of 0 to 'Note_off_c' events
# Key assumption that note velocity of 0 equals to a note off event
df[2] = df.apply(_convert_to_off, axis=1)
# rename df columns
df = df.rename(
columns={
0: "Track_id",
1: "Timings",
2: "Events",
3: "Time_signatures",
4: "Note_values",
5: "Velocity",
})
df.to_csv(midi_file[:-4] + ".csv") if save else None
return df
def miditocsvconvert(directory):
for subdir, dirs, files in os.walk(directory):
for filename in files:
filepath = subdir + os.sep + filename
if filepath.endswith(".midi"):
csv_string = py_midicsv.midi_to_csv(filepath)
newfile = filepath.replace('.midi', '.csv')
path = directory
f = open(os.path.join(path, newfile), 'w+')
for i in range(len(csv_string)):
f.write(csv_string[i])
def MidiToCsv(file):
import py_midicsv as pm
import pandas as pd
csv_file = pm.midi_to_csv(file)
dataframe = pd.DataFrame([sub.split(",") for sub in csv_file])
del csv_file, file
return dataframe
def process_midi(midipath):
"""returns dataframe of midi note-on events.
Arguments:
midipath {pathto.mid} -- path to .mid file
"""
midi_strings = py_midicsv.midi_to_csv(midipath)
midi_csv = get_midi_csv(midi_strings)
note_on_events = get_note_events(midi_csv)
label, midi_start = generate_blank_label(note_on_events)
insert_note_events(label, note_on_events, midi_start)
return label
def process_midi(midipath):
"""returns dataframe of midi note-on events.
Arguments:
midipath {pathto.mid} -- path to .mid file
"""
midi_strings = py_midicsv.midi_to_csv(midipath)
midi_csv = __get_midi_csv(midi_strings)
note_on_events = __get_note_events(midi_csv)
conversion_factor = __get_conversion_factor(midi_csv)
note_on_events = __calc_absolute_times(note_on_events, conversion_factor)
label, midi_start = __generate_blank_label(note_on_events)
abs_label = __generate_absolute_label(note_on_events)
__insert_abs_events(abs_label, note_on_events)
__insert_note_events(label, note_on_events, midi_start)
return abs_label
def compress_midi(_midi_files):
open("sorting/input_text.txt", "w").write("")
for file in _midi_files:
csv_string = pm.midi_to_csv(f"sorting/midi input/{file}")
compressed_csv = []
for i in range(len(csv_string)):
compressed_string = csv_string[i].split(", ")
if len(compressed_string) == 6 and "Note_off_c" not in compressed_string[2] \
and "Control_c" not in compressed_string[2] and "Header" not in compressed_string[2] \
and not compressed_string[-1] == "0\n":
compressed_csv.append([
int(compressed_string[1]),
tones_keys[int(compressed_string[4]) - 21],
int(compressed_string[4])
])
compressed_to_string(sorted(compressed_csv), file)
def _midToTxt(self, create_file=True):
'''
Converts midi files to txt files
returns True if successfully converted to txt file
returns False otherwise
Requires:
midiFolder: The folder the midi files are held in relative to current directory
fileName: The midifile name with extension
txtOutFolder: The name of the folder the out txt file should be put in
txtOutFileName: The name of the txt file that will be output by the converter
Effect:
Creates a new file in the txtOutFolder called [txtOutFileName].txt
Contents is in list format:
[channel, time note fires, midinotecommand, something, the midi note value, midi note volume]
[int, int, str, int, int, int]
Lists are sorted by time
***Visit https://glassarmonica.com/science/frequency_midi.php to convert midi note val to note info***
'''
# Assert the Midis folder exists later
midiLocation = './' + self._midDir + '/' + self._midFileName
outLocation = './' + self._outDir + '/' + self._outFileName
csv_string = py_midicsv.midi_to_csv(midiLocation)
# Turn all the midi information into lists
for ind, line in enumerate(csv_string):
line.strip('\n')
csv_string[ind] = list(map(self.__convertIfInt, line.split(',')))
# Sort the midi file by time
csv_string.sort(key=lambda x: x[1])
# And only list the note sections of the file
csv_string = filter(lambda x: 'Note' in x[2], csv_string)
with open(outLocation, 'w') as txtfile:
txtfile.write('')
while True:
try:
txtfile.write(str(next(csv_string)) + '\n')
except:
txtfile.write('[\'EOF\']')
return True
return False
def parse_midi_file(midi_filename, csv_filename=None):
"""
Decompiles a MIDI file into human-readable text
Inputs:
midi_filename - name of MIDI file to convert
csv_filename - name of csv file to output string to (optional), no file output if empty
Returns:
csv_string - string of all MIDI lines, according to the midicsv standard
"""
csv_string = py_midicsv.midi_to_csv(midi_filename)
# print(csv_string)
if csv_filename is not None:
# output to CSV file
with open(csv_filename, 'w') as csv_file:
for line in csv_string:
csv_file.write(line)
return csv_string
def midi2txt(path):
events_list = []
# Go through each MIDI file within the path
for file_name in os.listdir(path):
if file_name.lower().endswith('.mid'):
# Parse MIDI into a list where each element is a row in the CSV
csv_list = pm.midi_to_csv(path + "/" + file_name)
# Uncomment to save the csv file for each MIDI:
with open(rf'./{path}/{file_name}.txt', "w") as txt:
txt.writelines(csv_list)
# Put each row of the csv into a list
for i in range(len(csv_list)):
csv_list[i] = csv_list[i].split(",")
# Remove Spaces and \n's in each row element
for j in range(len(csv_list[i])):
csv_list[i][j] = csv_list[i][j].replace(' ', '').replace(
'\n', '')
str_list = csv2str(csv_list)
if TRANSPOSE_COUNT > 0:
rand_transpose_values = set()
while len(rand_transpose_values) < TRANSPOSE_COUNT:
random_num = random.randrange(0, 12)
rand_transpose_values.add(random_num)
# Transpose the original song and a transposed version of the song to events list
events_list.extend(str_list)
for number in rand_transpose_values:
events_list.extend(transpose(str_list, number))
print(len(events_list))
else:
events_list.extend(str_list)
# At this point, events_list is a 2d list containing all MIDI events in the dataset.
# Time unit is still in ticks
# Events_list is converted to a list of MidiEvent Objects
events_obj_list = str2objects(events_list)
# Object list is converted to text
objects2txt(events_obj_list)
def checking_csv(self, only_file_name):
csv_string = py_midicsv.midi_to_csv(self.output_file_dir +
str(self.epsilon_folder) + "/" +
"New_" + self.atype + "_" +
self.orig_midi_name + "_" +
only_file_name + ".mid")
tmp_list = []
for i in range(0, len(csv_string)):
temp = np.array(csv_string[i].replace("\n",
"").replace(" ",
"").split(","))
tmp_list.append(temp)
data = pd.DataFrame(tmp_list)
data.to_csv(
self.csv_output_dir + "New_" + self.atype + "_" +
self.orig_midi_name + "_" + only_file_name + ".csv",
header=False,
index=False,
)
print(".csv saved!")
def makesequences(file):
csvarr = [(s.split(",")) for s in py_midicsv.midi_to_csv(file)]
final = []
last_tick = 0
note = np.zeros(101)
for i in range(len(csvarr)):
line = csvarr[i]
time = int(line[1])
if line[2] == " Note_on_c":
if time > last_tick + 400:
last_tick = time
final.append(note)
note = np.zeros(101)
note[int(line[4].strip())] = 1
final.append(note)
eof = np.zeros(101)
eof[100] = 1
final.append(eof)
return final
def read_music(self, file: str, normalize: bool = False) -> str:
file_path = os.path.join(self.midi_dir, file)
csv_rows = pm.midi_to_csv(file_path)
csv_rows = list(
csv.reader(csv_rows, delimiter=',', skipinitialspace=True))
csv_rows = self.normalize_tempo(csv_rows)
note_offset = 0
if normalize:
note_offset = scarlatti_get_offset(filename=file)
encoded = ''
time_prev = 0
velocity_prev = '0'
for row in csv_rows:
m_track, m_time, m_type = row[0], int(row[1]), row[2]
wait_t = round((m_time - time_prev) / self.TIME_CONSTANT)
time_prev = m_time
if m_type == 'Note_on_c' or m_type == 'Note_off_c':
channel, note, velocity = row[3], row[4], row[5]
note = str(int(note) + note_offset)
if wait_t != 0:
encoded += ' ' + self.time_to_waits(wait_t)
if m_type == 'Note_off_c' or (m_type == 'Note_on_c'
and velocity == '0'):
encoded += ' endp' + note
elif m_type == 'Note_on_c':
if velocity != velocity_prev:
velocity_prev = velocity
velocity = int(velocity) // self.VELOCITIES
encoded += ' v' + str(velocity) + ' p' + note
else:
encoded += ' p' + note
return encoded
def music_decrypt(file_name):
csv_string = py_midicsv.midi_to_csv(file_name + ".mid")
degrees = [60, 62, 64, 65, 67, 69, 71, 72]
look_up_table = [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
['i', 'j', 'k', 'l', 'm', 'n', 'o', 'p'],
['q', 'r', 's', 't', 'u', 'v', 'w', 'x'],
['y', 'z', '0', '1', '2', '3', '4', '5'],
['6', '7', '8', '9', ',', '_', '.', ' ']]
lis = []
for i in csv_string:
s = i.split()
l = len(s)
if (l > 3):
lis.append([s[1], s[l - 2]])
temp = []
for i in lis:
i[0] = (i[0].split(',')[0])
i[1] = (i[1].split(',')[0])
if (i[1] != 'Tempo'):
if (i[1] >= '60'):
temp.append([int(i[0]), int(i[1])])
for n in range(1, len(temp)):
temp[n][0] = temp[n][0] - temp[n - 1][0]
print(temp)
max = 0
for n in range(len(temp)):
temp[n][1] = degrees.index(temp[n][1])
max = temp[n][0]
if (temp[n][0 > max]):
max = temp[n][0]
for n in range(len(temp)):
temp[n][0] = int(math.log(float(temp[n][0] / max), 2))
dec_txt = []
for n in range(len[temp]):
dec_txt.append(look_up_table[temp[n][0][temp[n][1]]])
print(dec_txt)
def read_midi_file(file_name,frequency):
try:
csv_string = py_midicsv.midi_to_csv(file_name)
except:
return []
beats_per_second = 0
heap_array = []
for row in csv_string.getvalue().split('\n'):
array_row = [x.strip() for x in row.split(',')]
if array_row[2] == 'Header':
beats_per_second = float(array_row[5])/frequency
if array_row[2] == 'Note_on_c' and array_row[5] != 0:
heap_element = [float(array_row[1])/beats_per_second, True, int(array_row[4])]
heap_array.append(heap_element)
if array_row[2] == 'Note_off_c' or (array_row[2] == 'Note_on_c' and array_row[5] == 0):
heap_element = [float(array_row[1])/beats_per_second, False, int(array_row[4])]
heap_array.append(heap_element)
heap_array.sort()
return heap_array
""" Main: Archivo que muestra el uso basico de la clase Comparator """
# Se utiliza el modulo py_midicsv para extraer las notas desde un archivo MIDI.
import py_midicsv as pm
# Sin embargo, lo unico necesario para utilizar esta clase es tener un lista de notas con la notacion en numero de las notas musicales.
from Comparator import Comparator
# Se cambia el formato del archivo de MIDI a CSV
OnRepeat = pm.midi_to_csv(r"dummy.mid")
# Extraccion de Notas de Archivo MIDI
notes = []
for l in OnRepeat:
line = l.split(",")
if len(line) >= 5:
if line[2] == " Note_on_c":
m = int(line[4])
notes.append(m)
# Se inicializa el objeto de la clase Comparator con los intervalos de la Escala Mayor
majorComp = Comparator([0, 2, 4, 5, 7, 9, 11])
notesStr = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
indiceMayor = majorComp.analyze(notes)
print("Indices Escala Mayor", indiceMayor)
print("\nEscala:", notesStr[indiceMayor.index(max(indiceMayor))], "mayor\n")
