Exemplo n.º 1
0
def apply_mutation(mutantnotelist, midino, snote=50, time=150, filename='random'):

    mid = MidiFile(type=0) # type0 can have only one track
    
    track = MidiTrack() # note list (kind of)

    mid.tracks.append(track)
    
    # Create mutant music folder if it does not exist
    if not os.path.exists('mutantmusic'):
        os.makedirs('mutantmusic')
    
    # add the octaves back
    mutantnotelist2 = [x+snote for x in mutantnotelist]
    
    for note in mutantnotelist2[:len(mutantnotelist2)-2]:
        
        #print(note)
        
        track.append(Message('note_on', note=int(note), velocity = 127, time=time))
        track.append(Message('note_off', note=int(note), velocity = 127, time=time))
        
    track.append(Message('note_on', note=mutantnotelist2[len(mutantnotelist2)-1], velocity = 127, time=time))
    track.append(Message('note_off', note=mutantnotelist2[len(mutantnotelist2)-1], velocity = 127, time=500))
        
        
    mid.save('mutantmusic/' + filename + str(midino) + '.mid')
Exemplo n.º 2
0
 def generate_midi(self, filename, length=100, delay=96):
     output = MidiFile()
     byte_list = super().generate_obj_list(length)
     track = parse_all(byte_list)
     for message in track:
         message.time = delay
     output.tracks.append(self.metamessages)
     output.tracks.append(track)
     output.save(filename)
Exemplo n.º 3
0
def split_midi_orch(f, c, list_instru):
    # Read a midi file and return a dictionnary {track_name : pianoroll}
    mid_in = MidiFile(f)
    mid_orch = MidiFile()
    mid_solo = MidiFile()
    # The two files need to have the same ticks per beat
    ticks_per_beat = mid_in.ticks_per_beat
    mid_orch.ticks_per_beat = ticks_per_beat
    mid_solo.ticks_per_beat = ticks_per_beat

    # get instrumentation
    with open(c, 'rb') as csvfile:
        reader = csv.DictReader(csvfile, delimiter=',')
        instrumentation = next(reader)

    # Parse track by track
    for i, track_in in enumerate(mid_in.tracks):
        if track_in.name not in instrumentation.keys():
            # probably a metadata track, usefull for both files
            mid_solo.tracks.append(track_in)
            mid_orch.tracks.append(track_in)
        elif instrumentation[track_in.name] in list_instru:
            mid_solo.tracks.append(track_in)
        else:
            mid_orch.tracks.append(track_in)

    # Create the files
    path_orch = re.sub(ur'\.mid$', ur'_orch.mid', f, flags=re.I|re.U)
    path_solo = re.sub(ur'\.mid$', ur'_solo.mid', f, flags=re.I|re.U)
    mid_orch.save(path_orch)
    mid_solo.save(path_solo)

    return path_orch, path_solo
Exemplo n.º 4
0
    def __init__(self, _save_path, songfile, _plyr_ctrls):
        super(PlayerThread, self).__init__()
        self.name = 'Player'
        self.stoprequest = threading.Event()
        self.plyr_ctrls = _plyr_ctrls
        self.chan_roles = [0 for i in range(10)]
        self.plyr_ctrls['songfile'] = songfile
        self.midifile = MidiFile(_save_path + songfile)
        # 0 - drum fill
        self.counter = [0 for i in range(4)]
        self.wt = WolfTonesSong()
        self.save_path = _save_path
        self.load_song(songfile)
        self.alt_meas = []

        #get the portname (system specific)
        env = socket.gethostname()
        if(env == 'record_synth'):
            names = str(mido.get_output_names())
            ports = names.split(',')
            sobj = re.search(r'Synth input port \(\d*:0\)', ports[0], flags=0)
            portname = sobj.group()
        if(env == 'colinsullivan.me'):
            #dummy port for testing on a headless server with no audio
            portname = 'Midi Through:Midi Through Port-0 14:0'
        self.outport = mido.open_output(portname, autoreset=True)
Exemplo n.º 5
0
def generate_random(snote=50, mlength=12, numofmidi=10, time=150, filename='random', pitchrnd=False):
    
    notes = range(snote, snote+mlength)
    
    noterange = range(mlength)

    # pitch range for random pitch value ;
    pitches = range(-8192,8191)
    
    # Create music folder if it does not exist
    if not os.path.exists('music'):
        os.makedirs('music')

    for j in range(numofmidi):
    
        mid = MidiFile(type=0) # type0 can have only one track
    
        track = MidiTrack() # note list (kind of)

        mid.tracks.append(track)
    
        # the note which the pitch will change for
        pitchnote = random.choice(noterange)
        numofpnote = random.choice(noterange)
    
        for i in noterange:
        
            note = random.choice(notes)
            pitch = random.choice(pitches)
        
            if pitchrnd:
                if i == pitchnote: # Change the pitch on the note
                    track.append(Message('pitchwheel', pitch=pitch))
                if i == (pitchnote+numofpnote): # Change the pitch back to default
                    track.append(Message('pitchwheel'))
        
            track.append(Message('note_on', note=note, velocity = 127, time=time))
            track.append(Message('note_off', note=note, velocity = 127, time=time))
            
        note = random.choice(notes)
        track.append(Message('note_on', note=note, velocity = 127, time=time))
        track.append(Message('note_off', note=note, velocity = 127, time=500))
        

        mid.save('music/' + filename + str(j) + '.mid')
Exemplo n.º 6
0
def time_warp(source_path, dest_path, ratio):
    # Read a midi file and return a dictionnary {track_name : pianoroll}
    mid_in = MidiFile(source_path)
    mid_out = MidiFile()
    # The two files need to have the same ticks per beat
    ticks_per_beat = mid_in.ticks_per_beat
    mid_out.ticks_per_beat = ticks_per_beat

    # Parse track by track
    for i, track_in in enumerate(mid_in.tracks):
        track_out = MidiTrack()
        mid_out.tracks.append(track_out)
        for message_in in track_in:
            time_in = message_in.time
            time_out = int(round(time_in * ratio))
            # For absolutely every message, just mutliply the time by the ratio
            message_out = message_in.copy(time=time_out)
            track_out.append(message_out)
    mid_out.save(dest_path)
    return
def createMidiFromPianoRoll(piano_roll, lowest_note, directory, mel_test_file, threshold, res_factor=1):
    
    ticks_per_beat = int(96/res_factor)
    mid = MidiFile(type=0, ticks_per_beat=ticks_per_beat)
    track = MidiTrack()
    mid.tracks.append(track)

    mid_files = []
    

    delta_times = [0]
    for k in range(piano_roll.shape[1]):#initial starting values
        if piano_roll[0, k] == 1:
            track.append(Message('note_on', note=k+lowest_note, velocity=100, time=0))
            delta_times.append(0)
        
    for j in range(piano_roll.shape[0]-1):#all values between first and last one
        set_note = 0 #Check, if for the current timestep a note has already been changed (set to note_on or note_off)
        
        for k in range(piano_roll.shape[1]):
            if (piano_roll[j+1, k] == 1 and piano_roll[j, k] == 0) or (piano_roll[j+1, k] == 0 and piano_roll[j, k] == 1):#only do something if note_on or note_off are to be set
                if set_note == 0:
                    time = j+1 - sum(delta_times)          
                    delta_times.append(time)
                else:
                    time = 0
                    
                if piano_roll[j+1, k] == 1 and piano_roll[j, k] == 0:
                    set_note += 1
                    track.append(Message('note_on', note=k+lowest_note, velocity=100, time=time))
                if piano_roll[j+1, k] == 0 and piano_roll[j, k] == 1:
                    set_note += 1
                    track.append(Message('note_off', note=k+lowest_note, velocity=64, time=time))
                           
    mid.save('%s%s_th%s.mid' %(directory, mel_test_file, threshold))
    mid_files.append('%s.mid' %(mel_test_file))
       
    return
Exemplo n.º 8
0
    def new_song(self):
            # save path here should be /songs/temp
            path = self.save_path
            fn = self.wt.get_by_genre(save_path=path)

            songfile = fn 
            self.midifile = MidiFile(songfile)
            self.plyr_ctrls['songfile'] = songfile
            #logging.debug(str(self.midifile.tracks))
            # length of a quarter note
            self.ticks_per_beat = self.midifile.ticks_per_beat
            #self.chan_roles = [0 for i in range(10)]
            for trk in self.midifile.tracks:
                s = trk.name.split(':')
                chan = s[0]
                role = s[1]
                #logging.debug('read  ' + chan + ' as ' + role)
                self.chan_roles[int(chan)] = role
                ld_role = len(re.match('ld', role)) > 0
                if(ld_role):
                    logging.debug('making riff')
                    self.make_riff(trk)
                logging.debug('Channel ' + str(chan) + ' is ' + role)
Exemplo n.º 9
0
 def load_song(self, filename):
         self.stop() 
         tmp = filename.split('.')
         # if you forget or are too lazy to type the filetype extenstion
         if(len(tmp) > 1 and tmp[-1] != 'mid'):
             filename += '.mid'
         songfile = self.save_path + filename
         self.wt.load_file(songfile)
         self.midifile = MidiFile(songfile)
         self.plyr_ctrls['songfile'] = filename
         #logging.debug(str(self.midifile.tracks))
         # length of a quarter note
         self.ticks_per_beat = self.midifile.ticks_per_beat
         #self.chan_roles = [0 for i in range(10)]
         for trk in self.midifile.tracks:
             s = trk.name.split(':')
             chan = s[0]
             role = s[1] 
             #logging.debug('read  ' + chan + ' as ' + role)
             self.chan_roles[int(chan)] = role
             if(role[-3:] == '_ld'):
                 logging.debug('making riff')
                 self.make_riff(trk)
             logging.debug('Channel ' + str(chan) + ' is ' + role)
Exemplo n.º 10
0
from mido import MidiFile
import os

filename = 'e-competition_out/2002/chan01.mid'
mid = MidiFile(filename)

directories = ['e-competition_out/2002/', 'e-competition_out/2004/', 'e-competition_out/2006/', 'e-competition_out/2008/', 'e-competition_out/2009/', 'e-competition_out/2011/']
#directories = ['e-competition_out/2011/']

notesOnPerDirectory = [0] * len(directories)

totalFiles = 0

for directoryIndex in range(len(directories)):
	directory = directories[directoryIndex]
	print('==> Analyzing directory %s'%(directory))
	# grab the files, assume they're all midi
	numNotesOnInDirectory = 0
	files = os.listdir(directory)
	for i in range(len(files)):
		if files[i] != '.DS_Store':
			totalFiles = totalFiles + 1
			print('Processing file %g out of %g in directory: %s'%(i, len(files), files[i]))
			mid = MidiFile(directory + files[i])
			curNumNotesOn = 0
			for msg in mid:
				if (msg.type == 'note_on'):
					curNumNotesOn = curNumNotesOn + 1
			print('%g Notes on in %s'%(curNumNotesOn, files[i]))
			numNotesOnInDirectory = numNotesOnInDirectory + curNumNotesOn
		else:
Exemplo n.º 11
0
    def __init__(self, *initial_data, **kwargs):

        np.random.seed(int(time.time()))  # random seed

        for dictionary in initial_data:  # allows for parameters to be loaded in as a dictionary
            for key in dictionary:
                setattr(gs, key, dictionary[key])
        for key in kwargs:
            setattr(gs, key, kwargs[key])

        self.start = time.time()

        # Launch PyGame
        pygame.init()
        pygame.mixer.init()
        pygame.display.set_caption(gs.GAME_TITLE)
        self.screen = pygame.display.set_mode(
            [gs.SCREEN_WIDTH, gs.SCREEN_HEIGHT])

        # Initialize a few useful variables
        self.font = pygame.font.SysFont("calibri", 20)
        self.reward = 0
        self.is_terminal = False
        self.count = +1
        self.clock = pygame.time.Clock()
        self.score = ""
        self.note_count = 0
        self.step_count = 0
        self.midi_notes = []

        if gs.USE_MIDI:
            if os.path.isdir(gs.MIDI_FILES_DIRECTORY):
                for file in os.listdir(gs.MIDI_FILES_DIRECTORY):
                    if file.endswith('.midi') or file.endswith('.mid'):
                        print("reading midi file: ", file)
                        midiFile = MidiFile(gs.MIDI_FILES_DIRECTORY + '/' +
                                            str(file))
                        for i, track in enumerate(midiFile.tracks):
                            for message in track:
                                if message.type == "note_on":
                                    #print("note: " + str(message.note) + " time: " + str(message.time))
                                    self.midi_notes.append(
                                        (message.note,
                                         message.time / gs.NOTE_SPEED))

        self.penalty_zone = Penalty()

        self.penalty_list = pygame.sprite.Group()
        self.penalty_list.add(self.penalty_zone)
        self.all_items_list = pygame.sprite.Group()
        self.arm_sprite_list = pygame.sprite.Group()
        self.arm_list = []
        self.note_list = pygame.sprite.Group()
        self.arm_actions = []
        for i in range(gs.NUMBER_OF_ARMS):
            arm = Arm(i, self.arm_list, start=gs.ARM_STARTS[i])
            self.arm_sprite_list.add(arm)
            self.all_items_list.add(arm)
            self.arm_actions.append(1)  # 1 means move in default direction
            self.arm_list.append(arm)
        self.last_time = time.time()
Exemplo n.º 12
0
#!/usr/bin/python

import sys, getopt
from mido import MidiFile

f = raw_input("Enter a file (relative to this file's directory):")

mid = MidiFile(f)

for i, track in enumerate(mid.tracks):
    #track is <meta message s
    for msg in track:
        #msg is the message in form "note_on/off channel=0 note=# velocity=# time=#
        pass
Exemplo n.º 13
0
import mido
import operator
from mido import MidiFile

filename = 'test3'
mid_in = MidiFile(filename + '_1.mid')

#change time
for i in range(0, len(mid_in.tracks) - 1, 1):
    t = 0
    if mid_in.tracks[i][0].type == 'note_on' or mid_in.tracks[i][
            0].type == 'note_off' or mid_in.tracks[i][
                0].type == 'polytouch' or mid_in.tracks[i][
                    0].type == 'control_change' or mid_in.tracks[i][
                        0].type == 'program_change' or mid_in.tracks[i][
                            0].type == 'aftertouch' or mid_in.tracks[i][
                                0].type == 'pitchwheel':
        mid_in.tracks[i][0].channel = 0
    for j in range(1, len(mid_in.tracks[i]) - 1, 1):
        t += mid_in.tracks[i][j].time
        mid_in.tracks[i][j].time = t
        if mid_in.tracks[i][0].type == 'note_on' or mid_in.tracks[i][
                0].type == 'note_off' or mid_in.tracks[i][
                    0].type == 'polytouch' or mid_in.tracks[i][
                        0].type == 'control_change' or mid_in.tracks[i][
                            0].type == 'program_change' or mid_in.tracks[i][
                                0].type == 'aftertouch' or mid_in.tracks[i][
                                    0].type == 'pitchwheel':
            mid_in.tracks[i][0].channel = 0

mid_out = MidiFile()
Exemplo n.º 14
0
def print_midi(file):
    midi = MidiFile(file)
    for i, track in enumerate(midi.tracks):
        print('Track {}: {}'.format(i, track.name))
        for msg in track:
            print(msg)
Exemplo n.º 15
0
class PlayerThread(threading.Thread):

    global plyr_ctrls

    def __init__(self, _save_path, songfile, _plyr_ctrls):
        super(PlayerThread, self).__init__()
        self.name = 'Player'
        self.stoprequest = threading.Event()
        self.plyr_ctrls = _plyr_ctrls
        self.chan_roles = [0 for i in range(10)]
        self.plyr_ctrls['songfile'] = songfile
        self.midifile = MidiFile(_save_path + songfile)
        # 0 - drum fill
        self.counter = [0 for i in range(4)]
        self.wt = WolfTonesSong()
        self.save_path = _save_path
        self.load_song(songfile)
        self.alt_meas = []

        #get the portname (system specific)
        env = socket.gethostname()
        if(env == 'record_synth'):
            names = str(mido.get_output_names())
            ports = names.split(',')
            sobj = re.search(r'Synth input port \(\d*:0\)', ports[0], flags=0)
            portname = sobj.group()
        if(env == 'colinsullivan.me'):
            #dummy port for testing on a headless server with no audio
            portname = 'Midi Through:Midi Through Port-0 14:0'
        self.outport = mido.open_output(portname, autoreset=True)

    def join(self, timeout=None):
        logging.debug('Player joining..')
        self.outport.reset()
        self.stoprequest.set()
        super(PlayerThread, self).join(timeout)

    def set_save_path(self, path, temp = False):
        if(path):
            self.save_path = path
        if(temp):
            self.save_path = path + 'temp' 

    def stop(self):
        self.plyr_ctrls['play'] = False

    def load_song(self, filename):
            self.stop() 
            tmp = filename.split('.')
            # if you forget or are too lazy to type the filetype extenstion
            if(len(tmp) > 1 and tmp[-1] != 'mid'):
                filename += '.mid'
            songfile = self.save_path + filename
            self.wt.load_file(songfile)
            self.midifile = MidiFile(songfile)
            self.plyr_ctrls['songfile'] = filename
            #logging.debug(str(self.midifile.tracks))
            # length of a quarter note
            self.ticks_per_beat = self.midifile.ticks_per_beat
            #self.chan_roles = [0 for i in range(10)]
            for trk in self.midifile.tracks:
                s = trk.name.split(':')
                chan = s[0]
                role = s[1] 
                #logging.debug('read  ' + chan + ' as ' + role)
                self.chan_roles[int(chan)] = role
                if(role[-3:] == '_ld'):
                    logging.debug('making riff')
                    self.make_riff(trk)
                logging.debug('Channel ' + str(chan) + ' is ' + role)
               
    def new_song(self):
            # save path here should be /songs/temp
            path = self.save_path
            fn = self.wt.get_by_genre(save_path=path)

            songfile = fn 
            self.midifile = MidiFile(songfile)
            self.plyr_ctrls['songfile'] = songfile
            #logging.debug(str(self.midifile.tracks))
            # length of a quarter note
            self.ticks_per_beat = self.midifile.ticks_per_beat
            #self.chan_roles = [0 for i in range(10)]
            for trk in self.midifile.tracks:
                s = trk.name.split(':')
                chan = s[0]
                role = s[1]
                #logging.debug('read  ' + chan + ' as ' + role)
                self.chan_roles[int(chan)] = role
                ld_role = len(re.match('ld', role)) > 0
                if(ld_role):
                    logging.debug('making riff')
                    self.make_riff(trk)
                logging.debug('Channel ' + str(chan) + ' is ' + role)
  
              
 
    def run(self):
        while(not self.stoprequest.isSet()):
            while(self.plyr_ctrls['play'] == True and not self.stoprequest.isSet()):
                #logging.debug('perc ' + str(self.plyr_ctrls['perc']))
                #logging.debug('bass ' + str(self.plyr_ctrls['bass']))
                was_playing = True
                ch_roles = self.chan_roles
                for msg in self.midifile.play():
                    if(self.plyr_ctrls['play'] == True and not self.stoprequest.isSet()):
     #-------------- MODIFY MIDI MESSAGES ON THE FLY  ------------------------
                        # Here do things that only happen once when a value changes
                        if(self.plyr_ctrls['val_chg'] == True):
                            self.plyr_ctrls['val_chg'] = False
                            pass
                        
                        if(msg.type == 'note_on' and msg.velocity):
                            ctrl_vel = self.plyr_ctrls[ch_roles[msg.channel]]
                            #logging.debug('ctrl_vel ' + str(ctrl_vel))
                            msg_vel = msg.velocity
                            msg.velocity = self.get_scaled_velocity(msg_vel, ctrl_vel) 
                            if(self.plyr_ctrls['drum_fill']):
                                if(ch_roles[msg.channel] == 'perc'):
                                    df_msg = msg.copy()
                                    df_msg.time = int(self.ticks_per_beat/16)
                                    df_msg.note = random.choice([35,36])
                                    df_msg.velocity = self.get_scaled_velocity(msg.velocity, 110)
                                    self.outport.send(df_msg)
                            if(self.plyr_ctrls['lead_fill']):
                                continue
                                role = ch_roles[msg.channel]
                                #if(len(self.alt_meas) > 1 and role[-3:] == '_ld'):
                                if(role[-3:] == '_ld'):
                                    logging.debug(len(self.alt_meas))
                                    lf_msg = msg.copy()
                                    lf_msg = self.alt_meas[self.counter[1]]
                                    self.counter[1] += 1
                                    if(self.counter[1] >= len(self.alt_meas)):
                                        self.counter[1] = 0
                                    self.outport.send(lf_msg)
     ############ SEND MIDI MESSAGE #######################################
                        self.outport.send(msg)
                    else:
                        if(was_playing == True):
                            self.outport.reset()
                            was_playing = False
                        break

    def get_scaled_velocity(self, msg_vel, ctrl_vel):
        ctrl_vel_ratio = float(ctrl_vel)/127
        #logging.debug('msg_vel ' +  str(msg_vel))
        #logging.debug('ratio ' +  str(ctrl_vel_ratio))
        if(ctrl_vel_ratio == 0.5):
             rtn_vel = msg_vel
        elif(ctrl_vel_ratio > 0.5):
             rtn_vel = msg_vel + ((127 - msg_vel)*((ctrl_vel/64)-1))
        elif(ctrl_vel_ratio < 0.5):
             rtn_vel = ctrl_vel_ratio * msg_vel * 2
        #logging.debug('rtn_vel ' +  str(rtn_vel))
        return int(rtn_vel)

    def make_riff(self, track):
        ticks_sum = 0
        msgs = []
        self.alt_meas = []
        if( not self.wt.scale):
            tmp_scale = [0,2,1,2,2,2,2,1]
        else:
            tmp_scale = self.wt.scale
        for i in range(36):
            rand_note = random.randint(0,len(tmp_scale)-1)
            steps = sum(tmp_scale[rand_note:-1])
            logging.debug('steps ' + str(steps))
            note = int(self.wt.key) + steps + random.randint(0,2)*12 
            len_note = [1,2,4,8,16]
            divisor = random.choice(len_note)
        
            time = int(self.ticks_per_beat/divisor)
            #logging.debug('note ' + str(self.wt.key))
            #logging.debug('time ' + str(time))
            #logging.debug('rand_note ' + str(rand_note))
        
            msg = Message('note_on', note=60, time=100)
Exemplo n.º 16
0
def showSampleInfo(input: str):
    from mido import MidiFile
    midi = MidiFile('music/sample/{}.mid'.format(input))
    for i, t in enumerate(midi.tracks):
        print('Track: {}, Instrument: {}'.format(i, t.name))
Exemplo n.º 17
0
import mido
from mido import MidiFile

output = mido.open_output()
fileName = "~/Desktop/mbot.midi"

for msg in MidiFile(fileName).play():
    output.send(msg)
    print(msg)
Exemplo n.º 18
0
 def saveFile(self, filename):
     midi = MidiFile()
     midi.tracks.append(self.track)
     midi.ticks_per_beat = self.ticksPerBeat
     midi.save(filename)
Exemplo n.º 19
0
from mido import Message, MidiFile, MidiTrack

mid = MidiFile()
track = MidiTrack()
mid.tracks.append(track)

track.append(Message('program_change', program=0, time=0))
# track.append(Message('note_on', note=64, velocity=64, time=32))
# track.append(Message('note_off', note=64, velocity=127, time=32))

i = 0
while i < 128:
    track.append(Message('note_on', note=i, velocity=96, time=0))
    track.append(Message('note_off', note=i, velocity=96, time=3840))
    print(i)
    i += 1

mid.save('0-127.mid')
Exemplo n.º 20
0
#!/usr/bin/env python
"""
Create a new MIDI file with some random notes.

The file is saved to test.mid.
"""
from __future__ import division
import random
import sys
from mido import Message, MidiFile, MidiTrack, MAX_PITCHWHEEL

notes = [64, 64+7, 64+12]

outfile = MidiFile()

track = MidiTrack()
outfile.tracks.append(track)

track.append(Message('program_change', program=12))

delta = 300
ticks_per_expr = int(sys.argv[1]) if len(sys.argv) > 1 else 20
for i in range(4):
    note = random.choice(notes)
    track.append(Message('note_on', note=note, velocity=100, time=delta))
    for j in range(delta // ticks_per_expr):
        pitch = MAX_PITCHWHEEL * j * ticks_per_expr // delta
        track.append(Message('pitchwheel', pitch=pitch, time=ticks_per_expr))
    track.append(Message('note_off', note=note, velocity=100, time=0))

outfile.save('test.mid')
Exemplo n.º 21
0
midiFile = 'SuperSmashBrosUltimate.mid'

# Other startup stuff
send = "\n"
time.sleep(3)


# Sends code to Arduino
def sendLine(code):
    print(int(code))
    ser.write((code + "\n").encode())
    # ser.write(send.encode())


# Opens and reads Midi file
for msg in MidiFile(midiFile):
    time.sleep(msg.time * 0.8)
    if not msg.is_meta:
        data = str(msg)

        # Filters out other initializing stuff
        if data[0:4] == "note":

            # If drive should turn on
            if data[6:7] == "n":
                if data[16] == "0":
                    code = ("3" + str(hertz[int(data[23:25])]) + "1")
                    sendLine(code)
                else:
                    code = ("2" + str(hertz[int(data[23:25])]) + "1")
                    sendLine(code)
Exemplo n.º 22
0
Play MIDI file on output port.

Run with (for example):

    ./play_midi_file.py 'SH-201 MIDI 1' 'test.mid'
"""
import sys
import mido
import time
from mido import MidiFile

filename = sys.argv[1]
if len(sys.argv) == 3:
    portname = sys.argv[2]
else:
    portname = None

with mido.open_output(portname) as output:
    try:
        midifile = MidiFile(filename)
        t0 = time.time()
        for message in midifile.play():
            print(message)
            output.send(message)
        print('play time: {:.2f} s (expected {:.2f})'.format(
                time.time() - t0, midifile.length))

    except KeyboardInterrupt:
        print()
        output.reset()
# from Generative Music's Class 2 Code
from mido import MidiFile
file_name = '21_knives_out'
mid = MidiFile('dataset/radiohead/' + file_name + '.mid')

# look at the track names
for i, track in enumerate(mid.tracks):
    print((i, track.name))

# create array of notes
notes = []
messages = []
for message in mid.tracks[7]:
    messages.append(message)

for m in range(len(messages)):
    # print messages[m]
    note = ""
    time = ""
    if messages[m].type == 'note_on':
        message_components = str(messages[m]).split(' ')
        for item in message_components:
            if 'note=' in item:
                # notes.append(item.split('note=')[1])
                note = item.split('note=')[1]
        message_components = str(messages[m + 1]).split(' ')
        for item in message_components:
            if 'time=' in item:
                time = item.split('time=')[1]
    if note != "":
        notes.append(str(note + "_" + time))
Exemplo n.º 24
0
if len( sys.argv ) > 3: samplerate = int(sys.argv[3])

win_s = 512 // downsample # fft size
hop_s = 256 // downsample # hop size

s = source(filename, samplerate, hop_s)
samplerate = s.samplerate

tolerance = 0.8

notes_o = notes("default", win_s, hop_s, samplerate)

print("%8s" % "time","[ start","vel","last ]")

# create a midi file
mid = MidiFile()
track = MidiTrack()
mid.tracks.append(track)

ticks_per_beat = mid.ticks_per_beat # default: 480
bpm = 120 # default midi tempo

tempo = bpm2tempo(bpm)
track.append(MetaMessage('set_tempo', tempo=tempo))
track.append(MetaMessage('time_signature', numerator=4, denominator=4))

def frames2tick(frames, samplerate=samplerate):
    sec = frames / float(samplerate)
    return int(second2tick(sec, ticks_per_beat, tempo))

last_time = 0
Exemplo n.º 25
0
def main():
    # key sig-time pairs
    global shortPhrases
    global longPhrases

    directory = input("Please enter a path to the desired directory: ")

    for filename in os.listdir(directory):
        if filename.endswith(".midi") or filename.endswith(".mid"):
            # print("FileName: ", filename)
            mid = MidiFile("MidiDataset/"+filename)
            key_sig = ''
            time_sig = ''
            numTicksBerBeat = 0
            shortPhraseList = []
            longPhraseList = []
            ticksSoFar = 0
            numerator = 0   # will be numerator of time signature
            denominator = 0 # will be denominator of time signature
            for i, track in enumerate(mid.tracks):
                for msg in track:
                    if msg.is_meta and msg.type == 'key_signature':
                        key_sig = msg.key
                    if msg.is_meta and msg.type == 'time_signature':
                        numerator = msg.numerator
                        # print("Numerator:", numerator)
                        denominator = msg.denominator
                        # print("denominator:", denominator)
                        # clocks per click = midi clock ticks per metronome beat
                        clocks_per_click = msg.clocks_per_click
                        notated_32nd_notes_per_beat = msg.notated_32nd_notes_per_beat
                        time_sig = str(numerator) + " / " + str(denominator)
                        numTicksBerBeat = clocks_per_click * notated_32nd_notes_per_beat
                    if key_sig != '' and time_sig != '':
                        keyTimePair = (key_sig, time_sig)
                        # print("KeyTimePair: ", keyTimePair)
                        if keyTimePair not in shortPhrases:
                            shortPhrases[keyTimePair] = []
                        if keyTimePair not in longPhrases:
                            longPhrases[keyTimePair] = []
                    if msg.is_meta == False and numerator != 0 and numTicksBerBeat != 0:
                        # generating phrases
                        if msg.type == "note_on" or msg.type == "note_off":
                            time = msg.time
                            ticksSoFar += int(time)
                            shortPhraseList.append(msg)
                            longPhraseList.append(msg)
                            if ticksSoFar % (numTicksBerBeat * int(numerator) * 4) == 0: # long phrase
                                ticksSoFar = 0
                                # print("Long Phrase:", longPhraseList)
                                # print()
                                longPhrases[keyTimePair].append(longPhraseList)
                                longPhraseList.clear()
                            # if ticksSoFar % (numTicksBerBeat * int(numerator)) == 0: # short phrases
                            if ticksSoFar % (numTicksBerBeat * int(numerator)) == 0:  # short phrases
                                # print("Short Phrase:", shortPhraseList)
                                # print()
                                shortPhrases[keyTimePair].append(shortPhraseList)
                                shortPhraseList.clear()
            # print("Short Phrases Dict: ", len(shortPhrases))
            # print("Long Phrases Dict: ", len(longPhrases))

    # test plays random long phrase (supposed to be 4 bars) in the key of C, 4/4 time
    rndLong = random.randrange(len(longPhrases[('C', '4 / 4')]))
    output = mido.open_output('IAC Driver Bus 1')
    test = toFile(longPhrases[('C', '4 / 4')][rndLong], 'C', '4 / 4', 375000, False)
    for msg in test.play():
        print(msg)
        output.send(msg)
Exemplo n.º 26
0
from mido import MidiFile, MidiTrack, Message
from keras.layers import LSTM, Dense, Activation, Dropout
from keras.preprocessing import sequence
from keras.models import Sequential, load_model
from keras.optimizers import RMSprop
from keras.callbacks import ModelCheckpoint
import numpy as np
import mido
import os
########### PROCESS MIDI FILE #############

notes = []
#count = 10
for filename in os.listdir('data/train/'):
    
    mid = MidiFile('data/train/'+filename)

    for msg in mid:
        if not msg.is_meta:
            if msg.type == 'note_on':
                note = msg.bytes()
                note[0] = msg.channel
                note.append(msg.time)
                notes.append(note)
    # count -=1
    # if count == 0: break

tr_size = len(notes)
###########################################

######## SCALE DATA TO BETWEEN 0, 1 #######
Exemplo n.º 27
0
import sys
from mido import Message, MetaMessage, MidiFile, MidiTrack

mid = MidiFile(type=0)
track = MidiTrack()
mid.tracks.append(track)

note = 46

track.append(Message('program_change', program=0, time=0))
track.append(Message('note_on', note=note, velocity=100, time=0))
track.append(Message('note_off', note=note, velocity=100, time=900))

mid.save(
    '/Users/scott.cook/PycharmProjects/MindVST/samples/midi_files/midi_As3_900ms.mid'
)

filename = '/Users/scott.cook/PycharmProjects/MindVST/samples/midi_files/midi_As3_900ms.mid'

midi_file = MidiFile(filename)

for i, track in enumerate(midi_file.tracks):
    sys.stdout.write('=== Track {}\n'.format(i))
    for message in track:
        sys.stdout.write('  {!r}\n'.format(message))
Exemplo n.º 28
0
from mido import MidiFile, MidiTrack, Message
import random

mid = MidiFile(type=0)

track = MidiTrack()

mid.tracks.append(track)

notes = range(40, 90)

for i in range(20):
    note = random.choice(notes)
    track.append(Message('note_on', note=note, velocity=100, time=i*100))
    track.append(Message('note_off', note=note, velocity=100, time=(i+1)*100))

mid.save('random.mid')

Exemplo n.º 29
0
parser.add_argument("-d","--dataPath", required=True, help="The path to the data that trained the model, to sigure out std and means to map back to original distrib")

parser.add_argument("-r","--ranges", required=True, metavar='range', nargs='+', help="The ranges in timesteps to imagine e.g. \"128:160\", \"200:280\" ")
# metavar='N', type=int, nargs='+'
parser.add_argument("-o","--outputMidi", help="The path to the output midi, if not given it will be assumed from input and model")

args = parser.parse_args()


#read in input midi
file_path = args.inputMidi
tokens = file_path.split("/")
file_name = tokens[len(tokens)-1]
file_name_no_ext = file_name.split(".")[0]

mid = MidiFile(file_path)

timeseries_tensor = utl.convert_midi_to_time_series(mid,5,5,8)

net = None

if args.networkType == "ConvNet_1_0_2":
    net = m.ConvNet_1_0_2().load_from_checkpoint(args.networkPath)
elif args.networkType == "TransformerNet_1_0_2":
    net = m.TransformerNet_1_0_2().load_from_checkpoint(args.networkPath)
else:
    print("Not supported type!")
    sys.exit()

net.eval()
Exemplo n.º 30
0
def write_midi(pr, quantization, write_path, tempo=80):
    def pr_to_list(pr):
        # List event = (pitch, velocity, time)
        T, N = pr.shape
        t_last = 0
        pr_tm1 = np.zeros(N)
        list_event = []
        for t in range(T):
            pr_t = pr[t]
            mask = (pr_t != pr_tm1)
            if (mask).any():
                for n in range(N):
                    if mask[n]:
                        pitch = n
                        velocity = int(pr_t[n])
                        # Time is incremented since last event
                        t_event = t - t_last
                        t_last = t
                        list_event.append((pitch, velocity, t_event))
            pr_tm1 = pr_t
        return list_event
    # Tempo
    microseconds_per_beat = mido.bpm2tempo(tempo)
    # Write a pianoroll in a midi file
    mid = MidiFile()
    # ticks_per_beat can be the quantization, this simplify the writing process
    mid.ticks_per_beat = quantization

    # Each instrument is a track
    for instrument_name, matrix in pr.iteritems():
        # A bit shity : if the pr is a binary pr, multiply by 127
        if np.max(matrix) == 1:
            matrix = matrix * 127
        # Add a new track with the instrument name to the midi file
        track = mid.add_track(instrument_name)
        # transform the matrix in a list of (pitch, velocity, time)
        events = pr_to_list(matrix)
        # Tempo
        track.append(mido.MetaMessage('set_tempo', tempo=microseconds_per_beat))
        # Add the program_change
        try:
            program = program_change_mapping[instrument_name]
        except:
            # Defaul is piano
            print instrument_name + " not in the program_change mapping"
            print "Default value is 1 (piano)"
            print "Check acidano/data_processing/utils/program_change_mapping.py"
            program = 1
        track.append(mido.Message('program_change', program=program))

        # This list is required to shut down
        # notes that are on, intensity modified, then off only 1 time
        # Example :
        # (60,20,0)
        # (60,40,10)
        # (60,0,15)
        notes_on_list = []
        # Write events in the midi file
        for event in events:
            pitch, velocity, time = event
            if velocity == 0:
                # Get the channel
                track.append(mido.Message('note_off', note=pitch, velocity=0, time=time))
                notes_on_list.remove(pitch)
            else:
                if pitch in notes_on_list:
                    track.append(mido.Message('note_off', note=pitch, velocity=0, time=time))
                    notes_on_list.remove(pitch)
                    time = 0
                track.append(mido.Message('note_on', note=pitch, velocity=velocity, time=time))
                notes_on_list.append(pitch)
    mid.save(write_path)
    return
Exemplo n.º 31
0
    ultimate = notes[-1][0]
    # rand = random.choice([ultimate, octave(ultimate)])
    queue[-1] = [[ultimate], notes[-1][1], 'unison']

    # for i in range(len(queue)):
    #     print(queue[i])

    #     batch_notes(queue[i][0], queue[i][1], 0, 1)
    return queue


if __name__ == "__main__":
    # test = MidiFile('test1.mid')
    # print_midi(test)

    mid = MidiFile()
    # t = MidiTrack()

    # t.append(Message('program_change', program=12, time=0))
    # t.append(Message('note_on', note=59, velocity=64, time=0))
    # t.append(Message('note_off', note=59, velocity=64, time=beats_to_ticks(2)))
    track.append(Message('program_change', program=12, time=0))

    # test = MidiFile('test3.mid')
    # # notes = get_notes(test)
    # # fscp = first_species(notes)

    # # for i in range(len(fscp)):
    # #     print(fscp[i])

    # #     batch_notes(fscp[i][0], fscp[i][1], 0, 1)
Exemplo n.º 32
0
#!/usr/bin/env python

import mido
from mido import Message, MidiFile

import time

infile = MidiFile('new_song.mid')

output = mido.open_output()

for msg in infile.play():
    output.send(msg)
Exemplo n.º 33
0
from mido import MidiFile
from mido.midifiles import MidiTrack
from mido import Message, MetaMessage
import time
import datetime

with MidiFile() as new_mid:
    new_track = MidiTrack()

    filename = "generated-music/round2-2.txt"
    with open(filename) as f:

        new_track.append(MetaMessage('set_tempo', tempo=500000 * 3))
        for line in f:

            parts = line.split()
            #c~0 n!1 v@2 t#3
            if parts[0] == "pw":
                if abs(int(float(parts[2].split('=')[1]))) < 8191:
                    new_track.append(
                        Message('pitchwheel',
                                channel=0,
                                pitch=int(float(parts[1].split('*')[1])),
                                time=int(float(parts[2].split('#')[1]))))
            elif parts[0] == "no":
                velocity = int(float(parts[2].split('%')[1]))
                velocity = velocity if velocity <= 127 else 127
                t = int(float(parts[3].split('#')[1]))
                t = t if t <= 127 else 127

                new_track.append(
Exemplo n.º 34
0
    def file_inp(self):
        self.file = askopenfilename(initialdir= os.getcwd(), filetypes = (("Mid files","*.mid"),
                                                                                ("Wav files","*.wav"),
                                                                                ("all files","*.*")))
        if str(self.file).strip('()') != str():
            self.lbl_title = Label(self.master, text=self.file.split('/')[-1][:25], font=("Arial", 10), width=20)
            self.lbl_title.grid(column=3, row=0, sticky="ew")
        
            if self.file.split('.')[-1] == 'mid':
                duration_secs = int(MidiFile(self.file).length)

            elif self.file.split('.')[-1] == 'wav':
                source_rate, source_sig = wav.read(self.file)
                duration_secs = int(len(source_sig) / float(source_rate))

            else: pass
        
            self.progressbar.config(mode = 'determinate', maximum = duration_secs*2+1, value = 0)
            self.progressbar.step(0)
           
            if self.file.split('.')[-1] == 'wav': 
                self.batch = 5000
                _, self.music_freq = wav.read(self.file)
                
            elif self.file.split('.')[-1] == 'mid':
                mid_file = converter.parse(self.file)
                self.music_freq = [0, ]
                
                for e in mid_file:
                    for f in e:
                        if type(f)==note.Note: 
                            self.music_freq = self.music_freq + [int(f.pitch.frequency)]
                            
                        elif type(f)==note.Rest: 
                            self.music_freq = self.music_freq + [0]
                            
                        elif type(f)==chord.Chord:
                            for g in f.pitches:
                                self.music_freq = self.music_freq + [int(g.frequency)]
                                
                        elif type(f)==stream.Voice:
                            for g in f.notes:
                                
                                if type(g)==note.Note: 
                                    self.music_freq = self.music_freq + [int(g.pitch.frequency)]
                                    
                                elif type(g)==note.Rest: 
                                    self.music_freq = self.music_freq + [0]
                                    
                                elif type(g)==chord.Chord:
                                    for h in g.pitches:
                                        self.music_freq = self.music_freq + [int(h.frequency)]
                                else: pass
                        else: pass
                
                lgth = len(self.music_freq)
                
                for i in range(1, lgth):
                    self.music_freq.insert(lgth-i+1, -self.music_freq[lgth-i])
                
                duration = int(MidiFile(self.file).length)
                self.batch = int(len(self.music_freq) / duration / 2)
                
            else: 
                self.batch = 5000
                self.music_freq = array([0 for x in range(self.batch)])
        
        else: pass
Exemplo n.º 35
0
    print("Writing file...")
    with open('single.csv', 'w') as f_handle:
        np.savetxt(f_handle, et_sample, fmt='%d', delimiter=",")
        np.savetxt(f_handle, mid_sample, fmt='%d', delimiter=",")

    num_midi += 1

    return 1


#
# begin main body of code
#

#mid = MidiFile(str(sys.argv[1]))
mid = MidiFile("KennyCB2.mid")

print("ticks: ", mid.ticks_per_beat)

for i, track in enumerate(mid.tracks):
    #print('Track {}: {}'.format(i, track.name))

    # check for cases where there is more than 1 track, we don't want this
    if i > 1:
        print("Error: More than one track found.")
        break

    # go through each midi message in the track
    for message in track:
        if (message.type == 'set_tempo'):
            tempo = message.tempo
Exemplo n.º 36
0



from mido import MidiFile
import mido
output = mido.open_output()
output.send(mido.Message('note_on', note = 60, velocity=64))


with input as mido.open_input('SH-201'):
	for message in input:
		print(message)

from mido import MidiFile
for message in MidiFile('song.mid').play():
	output.send(message)
p = mido.Parser()
p.feed([0x90, 0x40])
p.feed_byte(0x60)

p.pending()
for message in p:
	print(message)

#note_on channel=0 note=64 velocity=96 time=0

for message in MidiFile('song.mid').play():
	port.send(message)

from mido import Message
Exemplo n.º 37
0
#!/usr/bin/python

from mido import MidiFile
import sys

if len(sys.argv) != 2:
    print "Usage: {0} <midifile>".format(sys.argv[0])
    sys.exit(2)

midifile = sys.argv[1]

print "# Translating {}".format(midifile)

msgqueue = MidiFile(midifile)
timenow = 0.1
timeoffset = -1
channelmap = [2, 1, 0, 3, 4]
channels = ["pedal", "great", "swell", "choir", "posit"]
notes_on = [0, 0, 0, 0, 0]
notes_off = [0, 0, 0, 0, 0]
outputlist = []
for msg in msgqueue:
    timenow += msg.time
    if msg.type == "note_on" and msg.velocity > 0:
        if timeoffset < 0:
            timeoffset = timenow - 0.1
        payload = "N {} {} 1 ".format(channelmap[msg.channel], msg.note)
        target = "{:09.3f}:{}".format(timenow - timeoffset,
                                      channels[channelmap[msg.channel]])
        outputlist.append((target, payload))
        notes_on[channelmap[msg.channel]] += 1
Exemplo n.º 38
0
#dependencies
import mido
from mido import MidiFile, MidiTrack, Message
from keras.layers import LSTM, Dense, Activation, Dropout, Flatten
from keras.preprocessing import sequence
from keras.models import Sequential
from keras.optimizers import Adam
from keras.callbacks import ModelCheckpoint
from sklearn.preprocessing import MinMaxScaler
import numpy as np

#reading the midi files
#try just 1 first
mid = MidiFile('./jazz_data/4thAvenueTheme.mid')
notes = []

#extract note sequences
notes = []
for msg in mid:
    if not msg.is_meta and msg.channel == 0 and msg.type == 'note_on':
        data = msg.bytes()
        notes.append(data[1])

scaler = MinMaxScaler(feature_range=(0, 1))
scaler.fit(np.array(notes).reshape(-1, 1))
notes = list(scaler.transform(np.array(notes).reshape(-1, 1)))

#Prepare features for training and data subsample for prediction

# LSTM layers requires that data must have a certain shape
# create list of lists fist
Exemplo n.º 39
0
        print(*args, **kwargs)
else:
    vprint = lambda *a, **k: None  #do-nothing function

# Get import and export folder locations
dom = parse(ardourFile)
sessionName = dom.getElementsByTagName("Session")[0].getAttribute("name")

dir = os.path.dirname(ardourFile)
importFolder = os.path.join(dir, "interchange", sessionName, "midifiles")
exportFolder = os.path.join(dir, "export")
vprint(importFolder, exportFolder)

# Iterate through the MIDI tracks in Ardour (called "Routes" in the XML file)
# Gets Ardour track id's and saves track names
mid = MidiFile(type=1, ticks_per_beat=19200)
trackRef = {}  #ardour-track-id : midi-track-id
i = 0
for route in dom.getElementsByTagName("Route"):
    if route.getAttribute("default-type") == "midi":
        rname = route.getAttribute("name")
        if args.omitparens:
            p = re.compile("(.*)(\(.*\))(.*)")
            rname = p.sub(r"\1\3", rname).strip()
        mid.add_track(name=rname)
        mid.tracks[i].append(MetaMessage("instrument_name", name=rname))
        programNumber = getGeneralMidiNumber(rname)
        if programNumber == -10:
            mid.tracks[i].append(
                MetaMessage("channel_prefix", channel=10, time=0))
            if args.musescore:
Exemplo n.º 40
0
class CSVParser:
    def __init__(self, csv_file, deltaT):
        self.deltaT = deltaT
        self.csv_file = csv_file
        # default values cause yolo
        self.ticks_per_beat = 384
        self.tempo = 512820
        self.active_notes = [None] * 127
        self.mid = MidiFile(ticks_per_beat=self.ticks_per_beat)
        self.track = MidiTrack()
        self.mid.tracks.append(self.track)
        self.set_meta_tempo()
        self.last_note_time = 0

    def set_tempo(self, tempo):
        self.tempo = tempo

    def ms2sec(self, ms):
        return self.deltaT / 1000.

    def seconds2ticks(self, seconds):
        return second2tick(seconds, self.ticks_per_beat, self.tempo)

    def ticks2seconds(self, ticks):
        return tick2second(ticks, self.ticks_per_beat, self.tempo)

    def parse_row(self, row, index):
        notes = row.split(',')
        notes = map(int, notes)
        is_first = True
        for i in range(0, len(notes)):
            if notes[i] != 0:
                if self.active_notes[i] is None:
                    self.active_notes[i] = True
                    ticks = 0
                    if is_first:
                        ticks = self.seconds2ticks(index * self.ms2sec(
                            self.deltaT)) - self.last_note_time
                        self.last_note_time = self.seconds2ticks(
                            index * self.ms2sec(self.deltaT))
                        is_first = False
                    self.note_on(i, notes[i], int(ticks))
            else:
                if self.active_notes[i]:
                    ticks = 0
                    if is_first:
                        ticks = self.seconds2ticks(index * self.ms2sec(
                            self.deltaT)) - self.last_note_time
                        self.last_note_time = self.seconds2ticks(
                            index * self.ms2sec(self.deltaT))
                        is_first = False
                    self.note_off(i, int(ticks))
                    self.active_notes[i] = None

    def set_last_note(self, ticks):
        self.last_note_time = ticks

    def note_on(self, note, intensity, delta_ticks):
        self.track.append(
            Message('note_on', note=note, velocity=intensity,
                    time=delta_ticks))

    def note_off(self, note, delta_ticks):
        self.track.append(
            Message('note_off', note=note, velocity=64, time=delta_ticks))

    def set_meta_tempo(self):
        self.track.append(MetaMessage('set_tempo', tempo=self.tempo))

    def convert(self):
        with open(self.csv_file, 'r') as f:
            i = 0
            for line in f:
                self.parse_row(line, i)
                i += 1

    def save(self):
        self.mid.save(self.csv_file[:-4] + 'FromCSV.mid')
Exemplo n.º 41
0
def music(Key=0,
          BPM=0,
          Chord_prog=[0],
          beat=[0],
          song_name='new_song.mid',
          arpeggio=False,
          duree=8,
          instrumentbass=0,
          instrumentmain=0,
          probjump=0,
          probautocorr=0,
          probnextchordnote=0):
    print(duree)
    if Key == 0:
        Key = rd.randrange(36, 49)
    if BPM == 0:
        BPM = rd.randrange(50, 400)
    tempo = 60000 / BPM
    if Chord_prog == [0]:
        Chord_prog = cpg()
    Chord_roots = chord_root(Chord_prog)

    if beat == [0]:
        beat = bg_seq_combine(duree // 2)

    if instrumentbass == 0:
        instrumentbass = rd.randrange(0, 121)

    if instrumentmain == 0:
        instrumentmain = rd.randrange(0, 121)

    if probjump == 0:
        probjump = rd.randrange(1, 10)
    if probautocorr == 0:
        probautocorr = rd.random()
    if probnextchordnote == 0:
        probnextchordnote = rd.random()

    print('Chord progression:', Chord_prog, ', Key:', Key, ', BPM:', BPM,
          ', Beat:', beat)

    mid = MidiFile()
    track1 = MidiTrack()
    track2 = MidiTrack()
    track3 = MidiTrack()
    track4 = MidiTrack()
    melody = MidiTrack()
    mid.tracks.append(track1)
    mid.tracks.append(track2)
    mid.tracks.append(track3)
    mid.tracks.append(track4)
    mid.tracks.append(melody)

    track1.append(Message('program_change', program=instrumentbass, time=2))
    track2.append(Message('program_change', program=instrumentbass, time=2))
    track3.append(Message('program_change', program=instrumentbass, time=2))
    track4.append(Message('program_change', program=instrumentbass, time=2))
    melody.append(Message('program_change', program=instrumentmain, time=2))

    refrain = songbloc(Chord_prog, duree, couplet=0)
    couplet = songbloc(Chord_prog, duree, couplet=1)
    if Chord_prog[0] == 1:
        bridge_chords = cpg(starting_value=[2, 3, 6][rd.randrange(0, 3)])
    else:
        bridge_chords = cpg(starting_value=[1, 4, 5][rd.randrange(0, 3)])

    bridge = songbloc(bridge_chords, duree / 2, couplet=0)

    #### intro (melodie vide)
    melody.append(Message('note_on', note=32, velocity=0, time=0))
    melody.append(
        Message('note_off', note=32, velocity=127, time=int(4 * 8 * tempo)))
    melodie_tot = couplet[0] + refrain[0] + couplet[0] + refrain[0] + refrain[
        0]  #+bridge[0]+bridge[0]+refrain[0]+refrain[0]
    list_list_temps = couplet[1] + refrain[1] + couplet[1] + refrain[
        1] + refrain[1]  #+bridge[1]+bridge[1]+refrain[1]+refrain[1]
    # melodie_tot = bridge[0]
    # list_list_temps = bridge[1]
    print(melodie_tot)
    loop = 1
    flat_list_temps = []
    for sublist in list_list_temps:
        for item in sublist:
            flat_list_temps.append(item)
    print(flat_list_temps)
    for j in range(loop):
        for i in range(len(flat_list_temps)):
            lanote = Key + 12 + melodie_tot[i]
            temps = int(flat_list_temps[i] * tempo)

            melody.append(
                Message('note_on',
                        note=lanote,
                        velocity=rd.randrange(-20, 20) + 64,
                        time=0))
            melody.append(
                Message('note_off', note=lanote, velocity=127, time=temps))

    muted_beat = [[rd.randrange(0, 2) for x in range(len(beat))]
                  for y in range(4)]
    random_arpeggio = rd.randrange(0, 3)
    print(muted_beat)

    for x in range(4):
        for i in Chord_roots:
            if arpeggio == True or random_arpeggio == 1:
                arpChord2(Key + i, tempo, track1)
                if duree == 8:
                    arpChord2(Key + i, tempo, track1)
            else:
                Chord(Key + i, tempo, track1, beat, velocity=muted_beat[0])
                Chord(Key + i + 7, tempo, track2, beat, velocity=muted_beat[1])
                Chord(Key + i + 12,
                      tempo,
                      track3,
                      beat,
                      velocity=muted_beat[2])

                if i in [0, 5, 7]:
                    Chord(Key + i + 4,
                          tempo,
                          track4,
                          beat,
                          velocity=muted_beat[3])
                else:
                    Chord(Key + i + 3,
                          tempo,
                          track4,
                          beat,
                          velocity=muted_beat[3])

    # for x in range(2):
    #     for i in chord_root(bridge_chords):
    #         if arpeggio == True or random_arpeggio==1:
    #             arpChord2(Key + i, tempo, track1)
    #             if duree//2 == 8:
    #                 arpChord2(Key + i, tempo, track1)
    #         else:
    #             Chord(Key + i, tempo, track1, beat, velocity=muted_beat[0])
    #             Chord(Key + i + 7, tempo, track2, beat, velocity=muted_beat[1])
    #             Chord(Key + i + 12, tempo, track3, beat, velocity=muted_beat[2])
    #
    #             if i in [0, 5, 7]:
    #                 Chord(Key + i + 4, tempo, track4, beat, velocity=muted_beat[3])
    #             else:
    #                 Chord(Key + i + 3, tempo, track4, beat, velocity=muted_beat[3])

    for x in range(3):
        for i in Chord_roots:
            if arpeggio == True or random_arpeggio == 1:
                arpChord2(Key + i, tempo, track1)
                if duree == 8:
                    arpChord2(Key + i, tempo, track1)
            else:
                Chord(Key + i, tempo, track1, beat, velocity=muted_beat[0])
                Chord(Key + i + 7, tempo, track2, beat, velocity=muted_beat[1])
                Chord(Key + i + 12,
                      tempo,
                      track3,
                      beat,
                      velocity=muted_beat[2])

                if i in [0, 5, 7]:
                    Chord(Key + i + 4,
                          tempo,
                          track4,
                          beat,
                          velocity=muted_beat[3])
                else:
                    Chord(Key + i + 3,
                          tempo,
                          track4,
                          beat,
                          velocity=muted_beat[3])
    #fin
    #arpChord2(Key + Chord_roots[0], tempo, track1)
    tempo = int(tempo)
    track1.append(
        Message('note_on',
                note=Key + Chord_roots[0] - 12,
                velocity=(rd.randrange(-20, 20) + 40),
                time=0))
    track1.append(
        Message('note_off',
                note=Key + Chord_roots[0] - 12,
                velocity=127,
                time=tempo * 4))
    track2.append(
        Message('note_on',
                note=Key + Chord_roots[0] + 7 - 12,
                velocity=(rd.randrange(-20, 20) + 40),
                time=0))
    track2.append(
        Message('note_off',
                note=Key + Chord_roots[0] + 7 - 12,
                velocity=127,
                time=tempo * 4))
    track3.append(
        Message('note_on',
                note=Key + Chord_roots[0],
                velocity=(rd.randrange(-20, 20) + 40),
                time=0))
    track3.append(
        Message('note_off',
                note=Key + Chord_roots[0],
                velocity=127,
                time=tempo * 4))
    if Chord_roots[0] in [0, 5, 7]:
        track4.append(
            Message('note_on',
                    note=Key + Chord_roots[0] + 4 - 12,
                    velocity=(rd.randrange(-20, 20) + 40),
                    time=0))
        track4.append(
            Message('note_off',
                    note=Key + Chord_roots[0] + 4 - 12,
                    velocity=127,
                    time=tempo * 4))
    else:
        track4.append(
            Message('note_on',
                    note=Key + Chord_roots[0] + 3 - 12,
                    velocity=(rd.randrange(-20, 20) + 40),
                    time=0))
        track4.append(
            Message('note_off',
                    note=Key + Chord_roots[0] + 3 - 12,
                    velocity=127,
                    time=tempo * 4))
    attributs = {
        'Chord_progression': [Chord_prog],
        'Song_name': song_name,
        'Key': Key,
        'BPM': BPM,
        'Beat': [beat],
        'is_arpeggio': arpeggio == True or random_arpeggio == 1,
        'Melody': [melodie_tot],
        'Muted_beat': [muted_beat],
        'list_temps': [list_list_temps],
        # 'probability_pause':Average(list_prob_pause),
        # 'probability_2':Average(list_prob_2),
        # 'probability_1':Average(list_prob_1),
        # 'probability_05':Average(list_prob_05),
        'probability_jump': probjump,
        'probability_autocorrelation': probautocorr,
        'probability_next_chord_note': probnextchordnote,
        'instrument_bass': instrumentbass,
        'instrument_main': instrumentmain
    }

    data = pd.DataFrame(attributs,
                        columns=[
                            'Chord_progression', 'Song_name', 'Key', 'BPM',
                            'Beat', 'is_arpeggio', 'Melody', 'Muted_beat',
                            'list_temps', 'probability_jump',
                            'probability_autocorrelation',
                            'probability_next_chord_note', 'instrument_bass',
                            'instrument_main'
                        ])
    #'probability_pause', 'probability_2', 'probability_1', 'probability_05',
    mid.save(song_name)
    return (data)
Exemplo n.º 42
0
def midi_to_csv(midi_file, sampling_t, output_t):
    mid = MidiFile(midi_file)
    parser = NoteParser(mid, mid.ticks_per_beat, sampling_t, output_t)
    parser.parse()
Exemplo n.º 43
0
    def __init__(self, music_dir):

        log(INFO, 'Setting up MIDI reader')

        self.files = []
        self.files_count = 0
        self.play_in_progress = False
        self.play_file_index = -1
        self.play_event_index = -1

        log(INFO, 'Scanning {} directory for MIDI files'.format(music_dir))

        for dirname, dirnames, filenames in sorted(os.walk(music_dir)):

            for filename in sorted(filenames):

                fullname = os.path.join(dirname, filename)
                data = MidiFile(fullname, clip=True)
                tempo = midi.get_midi_file_tempo(data)
                events = midi.get_midi_file_events(data)
                length = int(data.length)

                if data.type == 2:

                    log(
                        WARNING,
                        'Dropping {}, as of unsupported MIDI type 2'.format(
                            filename))

                elif tempo == 0:

                    log(
                        WARNING,
                        'Dropping {}, as no valid tempo was found'.format(
                            filename))

                elif len(events) == 0:

                    log(
                        WARNING, 'Dropping {}, as no events were found'.format(
                            filename))

                else:

                    file_data = {}

                    file_data['name'] = filename
                    file_data['tempo'] = tempo
                    file_data['length'] = length
                    file_data['events'] = events
                    file_data['events_count'] = len(events)

                    log(
                        INFO, 'Registered file #{}: {}'.format(
                            self.files_count, filename))

                    self.files.append(file_data)
                    self.files_count += 1

        log(INFO, 'Found & parsed {} MIDI files'.format(self.files_count))

        return
Exemplo n.º 44
0
class Player:
    def __init__(self,
                 queue=Queue(),
                 running=Value('i', False),
                 tempo=Value('i', default_tempo),
                 deadline=Value('f', 0)):
        self.midiout = MidiOut()
        self.midi_for_file = MidiFile()
        self.last_chord = empty_chord

        self.queue_out = queue
        self.running = running
        self.tempo = tempo
        self.deadline = deadline
        self.start_peak = Value('f', 0)
        self.start_chord = 0

    def play_peak(self,
                  number=default_peak_number,
                  velocity=default_peak_velocity):
        note_on = Message('note_on',
                          note=number,
                          velocity=velocity,
                          channel=default_ultrasound_channel).bytes()
        self.midiout.send_message(note_on)
        sleep(default_peak_time)
        note_off = Message('note_off',
                           note=number,
                           velocity=min_velocity,
                           channel=default_ultrasound_channel).bytes()
        self.midiout.send_message(note_off)

    def play_chord_same_time(self):
        chord = self.queue_out.get()
        # print("player get", chord, "vel", chord.velocity, "queue", self.queue_out.qsize(), "time", time.monotonic())
        if chord.velocity > 127:
            chord.velocity = 127
        if chord.duration == 0:
            return
        for note in chord.notes:
            if note.number > 127:
                print("an incorrect note in player")
                return

        if self.last_chord != empty_chord:
            for note in self.last_chord.notes:
                note_off = Message('note_off',
                                   note=note.number,
                                   velocity=min_velocity,
                                   channel=default_channel).bytes()
                self.midiout.send_message(note_off)

        for note in chord.notes:
            note_on = Message('note_on',
                              note=note.number,
                              velocity=chord.velocity,
                              channel=default_channel).bytes()
            self.midiout.send_message(note_on)

        self.last_chord = chord

        sleep(len_in_s(chord.duration, self.tempo.value))

        if self.last_chord == chord:
            for note in chord.notes:
                note_off = Message('note_off',
                                   note=note.number,
                                   velocity=min_velocity,
                                   channel=default_channel).bytes()
                self.midiout.send_message(note_off)

    def play_chord_arpeggio(self, track=np.array([])):
        chord = self.queue_out.get()
        print("player get", chord, "vel", chord.velocity, "queue",
              self.queue_out.qsize(), "time", time.monotonic())
        if chord.velocity > 127:
            chord.velocity = 127
        if chord.duration == 0:
            return
        for note in chord.notes:
            if note.number > 127:
                print("an incorrect note in player")
                return
        chord.notes = sorted(chord.notes)
        if len(chord.notes) == 3:
            chord.notes.append(Note(chord.notes[0].number + 12))
        if track == np.array([]):
            notes_numbers = np.arange(len(chord.notes))
            notes_durations = np.array(
                [int(128 / len(chord.notes)) for i in range(len(chord.notes))])
            track = np.column_stack((notes_numbers, notes_durations))

        notes_sum_durations = np.cumsum(track.transpose(), axis=1)[1]
        if self.last_note_number is not None:
            note_off = Message('note_off',
                               note=self.last_note_number,
                               velocity=min_velocity,
                               channel=default_channel).bytes()
            self.midiout.send_message(note_off)
        self.start_chord = time.monotonic()
        pair = 0
        note_number = track[pair][0]
        note_on = Message('note_on',
                          note=chord.notes[note_number].number,
                          velocity=chord.velocity,
                          channel=default_channel).bytes()
        self.midiout.send_message(note_on)
        while (pair < len(track) - 1):
            # TODO
            if time.monotonic() > self.start_chord + max(
                (self.deadline.value - self.start_chord) *
                    notes_sum_durations[pair] / notes_sum_durations[-1],
                    len_in_s(notes_sum_durations[pair], self.tempo.value)):
                note_off = Message('note_off',
                                   note=chord.notes[note_number].number,
                                   velocity=min_velocity,
                                   channel=default_channel).bytes()
                self.midiout.send_message(note_off)
                pair += 1
                note_number = track[pair][0]
                note_on = Message('note_on',
                                  note=chord.notes[note_number].number,
                                  velocity=chord.velocity,
                                  channel=default_channel).bytes()
                self.midiout.send_message(note_on)
                self.last_note_number = chord.notes[note_number].number
            time.sleep(0.01)

    def put(self, chord):
        if type(chord) == Chord:
            self.queue_out.put(chord)
            return True
        return False

    def set_up_ports(self):
        """ This is necessary to HEAR the music """
        available_ports = self.midiout.get_ports()
        if available_ports:
            self.midiout.open_port(default_port)
        else:
            self.midiout.open_virtual_port("Tmp virtual output")

    def set_up_instrument(self, program=default_instrument):
        program_change = Message('program_change',
                                 program=program,
                                 channel=default_channel).bytes()
        self.midiout.send_message(program_change)

    def set_up_ultrasound_instrument(self,
                                     program=default_ultrasound_instrument):
        program_change = Message('program_change',
                                 program=program,
                                 channel=default_ultrasound_channel).bytes()
        self.midiout.send_message(program_change)

    def set_up_midi_for_file(self):
        self.midi_for_file.tracks.append(MidiTrack())

    def set_tempo(self, tempo=default_tempo):
        self.tempo.value = tempo

    def set_deadline(self, deadline=0):
        self.deadline.value = deadline

    def set_start_peak(self, start=max_time):
        self.start_peak.value = start

    def get_sleeping_time(self):
        return self.deadline.value - time.monotonic()

    def get_track(self):
        return self.midi_for_file.tracks[0]

    def save_file(self, filename='my track.mid'):
        self.midi_for_file.save(filename)
        return filename

    def run(self):
        self.running.value = True
        self.set_up_ports()
        self.set_up_midi_for_file()
        self.set_up_instrument()
        self.set_up_ultrasound_instrument()

        self.queue_process = Process(target=run_queue_out, args=(self, ))
        self.queue_process.start()

        self.queue_process = Process(target=run_peak, args=(self, ))
        self.queue_process.start()

    def stop(self):
        """ All chords that already sound will continue to sound """
        self.running.value = False
        self.queue_process.join()
        self.queue_process.join()
        self.queue_out = Queue()

    queue_out = None
    running = None
    tempo = None
    deadline = None
    start_peak = None
    start_chord = None
    queue_process = None
    peak_process = None
    midiout = None
    midi_for_file = None
    last_chord = None
    last_note_number = None
Exemplo n.º 45
0
def load_midi_file(files_mid):
    mid = MidiFile(files_mid, clip=False)
    if (mid.length >= 30):
        return mid
    else:
        return 0
Exemplo n.º 46
0
#import mido
from mido import MidiFile
mid = MidiFile('../Melancholy_-_Piano_Solo_Arrangement.mscz.mid')

print(mid)

for i, track in enumerate(mid.tracks):
    print('Track {}: {}'.format(i, track.name))
    for msg in track:
        print(msg)
Exemplo n.º 47
0
def runModel():
    if not args.train:
        if args.conv:
            model = createConvModel()
        else:
            model = createLSTMModel()
        model.load_weights(args.load_weights)

    #start with some random notes to generate off of
    ls = []
    for x in range(lengthSample):
        ls.append(random.randint(0, dataInd.shape[0]))

    #set up midi file
    mid = MidiFile()
    track = MidiTrack()
    mid.tracks.append(track)
    track.append(Message('program_change', program=12))

    time = 0
    #run for 10 seconds
    while time < 10.:
        print(str(ls[-5:]) + " " + str(time))

        #predict
        res = model.predict(
            np.expand_dims(np.array(ls[-lengthSample:]), axis=0))[0]
        listAdd = res

        #convert to note
        res = indToNote(np.argmax(np.array(res)))
        time += res[2]
        res[0] = np.rint(res[0])
        res[1] = np.rint(res[1] * 127)
        res[2] = np.rint(res[2] * 880)

        if (res[0] > 0):
            track.append(Message('note_on', note=int(res[1]),
                                 time=int(res[2])))
        else:
            track.append(
                Message('note_off', note=int(res[1]), time=int(res[2])))

        #convert back to a format the mdoel can read
        res[1] = res[1] / 127.
        res[2] = res[2] / 880.

        #append the note to the running list of notes
        ls.append(np.argmax(np.array(listAdd)))

        #ocasionally add random notes
        #helps avoid loops
        if time % 2. <= 0.05:

            addInd = random.randint(0, len(data[data.shape[0] - 1]))
            add = data[data.shape[0] - 1][addInd:addInd + 5]
            # for x in range(5):
            # 	add[x] = noteToInd(add[x])
            ls += add
            #ls.append(random.randint(0,dataInd.shape[0]))
    mid.save(args.save_song_path + 'new_song.mid')
import mido
from mido import MidiFile
from mido.midifiles import MidiTrack
from mido import Message

# pattern = MidiFile('Songs/Suteki-Da-Ne.mid')
pattern = MidiFile("Songs/twinkle_twinkle.mid")
mid = MidiFile()


tracks = MidiTrack()
tracks.append(tracks)
"""
for message in pattern:
    
    
    if message.type == 'note_on' or message.type == 'note_off':
        #print message
        mid.tracks.append(mid.Message(message.type, note=message.note, velocity=message.velocity, time=message.time))
    #elif message.type == 'control_change':
    #    mid.tracks.append(Message(message.type, control=message.control, value=message.value, time=message.time))
    
    #else:
    #    print message
    #    print message.type
    
    
    #tracks.append(Message(message.type, note=message.note, velocity=message.velocity, time=message.time))
    #tracks.append(message)

"""