def predict():
now = time.time()
values = json.loads(request.data)
midi_data = pretty_midi.PrettyMIDI(
StringIO(''.join(chr(v) for v in values)))
duration = float(request.args.get('duration'))
ret_midi = generate_midi(midi_data, duration)
# Store the received midi file in a temporary file to be able to use it with mido
mfile = tempfile.NamedTemporaryFile()
midi_data.write(mfile)
mfile.seek(0)
midofile = mido.MidiFile(mfile.name)
mood = predictmood(midofile)
print mood
# Add a new track with the first note indicating the mood
midi_to_mod = mido.MidiFile(ret_midi.name)
midi_to_mod.tracks.append(HappyTrack() if mood == 'happy' else SadTrack())
ret_file = tempfile.NamedTemporaryFile()
midi_to_mod.save(ret_file.name)
ret_file.seek(0)
return send_file(ret_file,
attachment_filename='return.mid',
mimetype='audio/midi',
as_attachment=True)
def predict(pitchNums):
now = time.time()
#initialize midi data and instrument
midi_data = pretty_midi.PrettyMIDI()
myInstru = pretty_midi.Instrument(program=0)
timeTracker = 0.0 #track the entire duration of the input midi data
#generate midi notes and append to the midi instrument
for i in pitchNums:
randDura = 0.1
note = pretty_midi.Note(velocity=100,
pitch=i,
start=timeTracker,
end=timeTracker + randDura)
myInstru.notes.append(note)
timeTracker += randDura
# print("my notes:")
# print(myInstru.notes)
midi_data.instruments.append(myInstru)
duration = timeTracker + 1.0
# print("this is duration")
# print(duration)
ret_midi = generate_midi(midi_data, duration)
ret_midi_data = pretty_midi.PrettyMIDI(ret_midi)
print("returned midi")
playOutputMidi()
def predict():
now = time.time()
# values = json.loads(request.data) #avenote reads input
values = [
77, 84, 104, 100, 0, 0, 0, 6, 0, 0, 0, 1, 1, 224, 77, 84, 114, 107, 0,
0, 0, 59, 0, 255, 81, 3, 7, 161, 32, 0, 144, 72, 127, 89, 144, 71, 127,
22, 128, 72, 90, 22, 144, 69, 127, 17, 128, 71, 90, 95, 128, 69, 90,
16, 144, 72, 127, 73, 144, 71, 127, 0, 128, 72, 90, 17, 144, 69, 127,
22, 128, 71, 90, 22, 128, 69, 90, 0, 255, 47, 0
]
print("the input data is loaded")
print(values)
# or we send in on our own
# values = our_own_function()
midi_data = pretty_midi.PrettyMIDI(
StringIO(''.join(chr(v) for v in values)))
print("midi file")
print(midi_data)
duration = float(request.args.get('duration'))
ret_midi = generate_midi(midi_data,
duration) #avenote send generated output
return send_file(ret_midi,
attachment_filename='return.mid',
mimetype='audio/midi',
as_attachment=True)
def predict():
print('predicting.....')
now = time.time()
start_time = float(request.args.get('start_time'))
if start_time != 0:
session_time = start_time
midi_path = midipath + str(session_time)
os.mkdir(midi_path)
else:
midi_path = midipath
values = json.loads(request.data)
valuesStr = (''.join(chr(v) for v in values))
valBytes = BytesIO(bytes(valuesStr, 'latin1'))
midi_data = pretty_midi.PrettyMIDI(valBytes)
for note in midi_data.instruments[0].notes:
note.velocity = 64
prime_midi_loc = os.path.join(midi_path, prime_name)
total_midi_loc = os.path.join(midi_path, total_midi_name)
partial_midi_loc = os.path.join(midi_path, partial_midi_name)
midi_data.write(prime_midi_loc)
print('setting retMidi')
ret_midi = generate_midi(prime_midi_loc, partial_midi_loc, total_midi_loc)
return send_file(ret_midi,
attachment_filename='return.mid',
mimetype='audio/midi',
as_attachment=True)
def predict_frames():
print('predicting.....')
now = time.time()
values = json.loads(request.data)
midi_data = pretty_midi.PrettyMIDI()
piano = pretty_midi.Instrument(program=0)
for cNote in values['notes']:
print(cNote)
note = pretty_midi.Note(velocity=cNote['velocity'],
pitch=cNote['pitch'],
start=cNote['startTime'],
end=cNote['endTime'])
piano.notes.append(note)
midi_data.instruments.append(piano)
print('setting retMidi', midi_data)
midi_path = midipath
prime_midi_loc = os.path.join(midi_path, prime_name)
total_midi_loc = os.path.join(midi_path, total_midi_name)
partial_midi_loc = os.path.join(midi_path, partial_midi_name)
midi_data.write(prime_midi_loc)
print('setting retMidi')
ret_midi = generate_midi(prime_midi_loc, partial_midi_loc, total_midi_loc)
return send_file(ret_midi,
attachment_filename='return.mid',
mimetype='audio/midi',
as_attachment=True)
def predict():
values = json.loads(request.data)
midi_data = pretty_midi.PrettyMIDI(
StringIO(''.join(chr(v) for v in values)))
duration = float(request.args.get('duration'))
ret_midi = generate_midi(midi_data, duration)
return send_file(ret_midi, attachment_filename='return.mid',
mimetype='audio/midi', as_attachment=True)
def predict():
now = time.time()
values = json.loads(request.data)
midi_data = pretty_midi.PrettyMIDI(StringIO(''.join(chr(v) for v in values)))
duration = float(request.args.get('duration'))
ret_midi = generate_midi(midi_data, duration)
return send_file(ret_midi, attachment_filename='return.mid',
mimetype='audio/midi', as_attachment=True)
def predict():
notes = json.loads(request.get_data())
midi_data = pretty_midi.PrettyMIDI(StringIO("".join(chr(n)
for n in notes)))
duration = float(request.args.get("duration")) #seconds
generated = predictor.generate_midi(midi_data, duration)
return send_file(generated,
attachment_filename="output.mid",
mimetype="audio/midi",
as_attachment=True)
def predict():
midi_data = json.loads(request.data)
#duration = float(request.args.get('duration'))
print(midi_data)
pitches = midi_data["pitches"]
start_times = midi_data["start_times"]
durations = midi_data["durations"]
tempo = midi_data["tempo"]
length = midi_data["length"]
ret_midi = generate_midi(pitches, start_times, durations, tempo, length)
return json.dumps(ret_midi)
def run(self):
print "Starting " + self.name
# Get lock to synchronize threads
ret_midi = generate_midi(self.midi_data, self.duration)
midi_data = pretty_midi.PrettyMIDI(ret_midi.name)
if len(midi_data.instruments) > 0:
for midi_note in midi_data.instruments[0].notes:
threadLock.acquire()
app.ai_midis.append({
"pitch": midi_note.pitch,
"velocity": midi_note.velocity
})
threadLock.release()
def predict():
now = time.time()
values = json.loads(request.data)
if sys.version_info.major <= 2:
midi_data = pretty_midi.PrettyMIDI(
StringIO(''.join(chr(v) for v in values)))
else:
midi_data = pretty_midi.PrettyMIDI(
BytesIO(b''.join([v.to_bytes(1, 'big') for v in values])))
duration = float(request.args.get('duration'))
ret_midi = generate_midi(midi_data, duration)
return send_file(ret_midi,
attachment_filename='return.mid',
mimetype='audio/midi',
as_attachment=True)
def predict():
notes = json.loads(request.get_data())
if sys.version_info.major <= 2:
from cStringIO import StringIO
note_stream = StringIO("".join(chr(n) for n in notes))
else:
from io import BytesIO
note_stream = BytesIO("".join(chr(n) for n in notes).encode("latin1"))
midi_data = pretty_midi.PrettyMIDI(note_stream)
duration = float(request.args.get("duration")) #seconds
generated = predictor.generate_midi(midi_data, duration)
return send_file(generated,
attachment_filename="output.mid",
mimetype="audio/midi",
as_attachment=True)
def predict():
print('predicting.....')
now = time.time()
# print(request.data)
values = json.loads(request.data)
start_time = float(request.args.get('start_time'))
if start_time!=0:
session_time = start_time
midi_path = midipath + str(session_time)
os.mkdir(midi_path)
else:
midi_path = midipath
# print(values)
# for v in values:
# print(v)
# midi_data = pretty_midi.PrettyMIDI(StringIO(''.join(chr(v) for v in values)))
# midi_data = pretty_midi.PrettyMIDI(prime_loc)
values = json.loads(request.data)
# print('creating midi data', values)
valuesStr = (''.join(chr(v) for v in values))
valBytes = BytesIO(bytes(valuesStr, 'latin1'))
midi_data = pretty_midi.PrettyMIDI(valBytes)
for note in midi_data.instruments[0].notes:
note.velocity=64
prime_midi_loc = os.path.join(midi_path,prime_name)
total_midi_loc = os.path.join(midi_path,total_midi_name)
partial_midi_loc = os.path.join(midi_path,partial_midi_name)
# if start_time==0:
# previous_midi = pretty_midi.PrettyMIDI(total_midi_loc)
# first_time = previous_midi.instruments[0].notes[0].start
# last_time = previous_midi.instruments[0].notes[-1].end
# print('concat midi file')
# for note in midi_data.instruments[0].notes:
# note.start = note.start + last_time + 0.5
# note.end = note.end + last_time + 0.5
# previous_midi.instruments[0].notes.append(note)
# else:
# previous_midi = midi_data
# first_time = previous_midi.instruments[0].notes[0].start
# last_time = previous_midi.instruments[0].notes[-1].end
# print('first time is')
# print(first_time)
# print('last time is')
# print(last_time)
# cut_note_index = 0
# shift_time = 0
# if last_time -first_time > 30:
# print('longer than 30s, cut prime')
# for i in range(len(previous_midi.instruments[0].notes)):
# if last_time - previous_midi.instruments[0].notes[i].start< 30:
# cut_note_index = i
# shift_time = previous_midi.instruments[0].notes[cut_note_index].start
# print("shift_time is")
# print(shift_time)
# break
# previous_midi.instruments[0].notes = previous_midi.instruments[0].notes[i:]
# for note in previous_midi.instruments[0].notes:
# note.start -= shift_time
# note.end -= shift_time
midi_data.write(prime_midi_loc)
# print('setting duration')
# duration = float(request.args.get('duration'))
print('setting retMidi')
ret_midi = generate_midi(prime_midi_loc,partial_midi_loc,total_midi_loc)
return send_file(ret_midi, attachment_filename='return.mid',
mimetype='audio/midi', as_attachment=True)
