示例#1
0
    def test_running_status(self):
        return # Running doesn't work with PortMidi, so it's turned off.

        # Two note_on messages. (The second has no status byte,
        # so the last seen status byte is used instead.)
        a = mido.parse_all([0x90, 0x01, 0x02, 0x01, 0x02])
        b = [Message('note_on', note=1, velocity=2)] * 2
        self.assertEqual(a, b)

        # System common messages should cancel running status.
        # (0xf3 is 'songpos'. This should be 'song song=2'
        # followed by a stray data byte.
        a = mido.parse_all([0xf3, 2, 3])
        b = [Message('song', song=2)]
        self.assertEqual(a, b)
示例#2
0
def bruteforce_sound(path_to_wav,
                     synth_def,
                     params_def,
                     target_score=50,
                     pop_size=50,
                     max_generations=100,
                     mutation_rate=0.05,
                     midi_channel=10,
                     midi_device=None):
    global best_patch
    print('z', synth_def)
    # synth = SimpleCCPatch(midi_channel, synth_def, ['Feedback', 'Mix'])
    synth = SimpleCCPatch(midi_channel, synth_def, [
        'Algo', 'Ratio C', 'Ratio A', 'Ratio B1', 'Ratio B2', 'Harmonics',
        'Detune', 'Feedback', 'Mix', 'A Level', 'B Level'
    ])
    outport = mido.open_output(midi_device)
    comp = MFCCComparator(path_to_wav)
    length = comp.target_length
    gm = GeneticModel(pop_size, mutation_rate, epoch=30)
    gm.test_function = lambda S: try_speciman(synth, outport, midi_channel,
                                              comp, gm, S, length)
    for param in params_def:
        gm.add_param(param['name'], param['min'], param['max'])
    best_result = -1
    for i in range(max_generations):
        print(f"Generation {i+1}/{max_generations}")
        generation = gm.iterate()
    # Send best patch
    for cmd in mido.parse_all(best_patch):
        outport.send(cmd)
示例#3
0
def main():
    """Parse a note_on msg and compare it to one created with Message()."""

    #message = mido.parse(b'\x90\x4c\x20')

    messages = mido.parse_all(b'\xB5\x8D\x80\x15\x40')
    for message in messages:
        print(message)
示例#4
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)
示例#5
0
    def wait_for_messages(self):
        while 1:
            socket_list = [self.sock]

            # Get the list sockets which are readable
            read_sockets, write_sockets, error_sockets = select.select(
                socket_list, [], [], 0)
            for sock in read_sockets:
                # incoming message from remote server
                if sock == self.sock:
                    data = sock.recv(4096)
                    if not data:
                        print('\nDisconnected from chat server')
                        sys.exit()
                    else:
                        # print data
                        #sys.stdout.write(">" +  str(binascii.unhexlify(data.decode())) + "<")
                        #print("Received1: " + data.decode())
                        messages = str(data.decode()).split("m")
                        if len(messages) >= 2:
                            messages.pop(0)
                            for message in messages:
                                message_header = message[:1]
                                message_body = message[2:]
                                print(message)
                                if message_header == "n":
                                    notes_hex = message_body
                                    notes_bin = bytearray.fromhex(notes_hex)
                                    notes_mido = mido.parse_all(notes_bin)
                                    print(notes_mido)
                                    if self.midi_ports != None:
                                        for note in notes_mido:
                                            if isinstance(note, Message):
                                                self.midi_ports_out.send(note)
                                            elif note.type == 'set_tempo':
                                                print(
                                                    'Tempo changed to {:.1f} BPM.'
                                                    .format(
                                                        tempo2bpm(note.tempo)))

            if self.midi_ports != None:
                msg = ''
                bytes = bytearray()
                for message in mido.ports.multi_receive(self.midi_ports,
                                                        block=False):
                    print('Sending: {}'.format(message))
                    bytes = bytes + message.bin()
                if bytes != b'':
                    message = "mn=" + bytes.hex()
                    #hex = "mn=803c00"
                    #hex = "mn=803c00mn=903740"
                    print("Sent: " + message)
                    self.sock.send(message.encode())
示例#6
0
def message(p1):
  """
  This function will use the `mido` python midi module
  to generate a midi message (which can later be sent to a `mido` midi output)
  """
  sysex=[0xf0]
  sysex.extend([0x41, 0x35, 0x00, 0x21, 0x20, 0x01])
  sysex.extend(p1.bytes())
  sysex.extend([0xf7])
  return mido.parse_all(sysex)[0]


  if __name__ == '__main__':
    print 's\'all good, homie.'
示例#7
0
def try_speciman(synth, midi_device, channel, comp, genetic_model, speciman,
                 sample_length):
    global best_score
    global best_patch
    global best_count
    for (param, value) in zip(genetic_model.params, speciman.values):
        synth.set_param(param['key'], int(round(value)))
        # print(f'{param["key"]} = {int(round(value))}; ', end='')
    patch = synth.get_patch()
    # print('zxz', midi_device)
    outport = midi_device
    # outport = mido.open_output(midi_device)
    # send patch
    # midi.send(patch)
    # record wav
    # wav = record(sample_length, comp.sample_rate, 100)
    for cmd in mido.parse_all(patch):
        outport.send(cmd)
    wav = sd.rec(sample_length + 800, comp.sample_rate, channels=1)
    outport.send(mido.Message('note_on', channel=channel, note=48))
    # time.sleep(.001)
    sd.wait()
    outport.send(mido.Message('note_off', channel=channel, note=48))
    wav = trimpad(wav, 0.01, comp.target_length)
    normwav = normalize(wav)
    # wavfile.write(f'specimenx/feedback{speciman.values[0]}.wav', 48000, normwav)
    # wavfile.write(f'specimenx/orig{speciman.values[0]}.wav', 48000, wav)
    score = comp.compare_to(normwav, 48000)
    if score < best_score:
        wavfile.write(f'specimen/best{best_count}.wav', 48000, normwav)
        # wavfile.write(f'specimen/bestn{best_count}.wav', 48000, normwav)
        best_score = score
        best_patch = patch
        print(f'{best_count}. ', end='')
        best_count += 1
        for (param, value) in zip(genetic_model.params, speciman.values):
            synth.set_param(param['key'], int(round(value)))
            print(f'{param["key"]} = {int(round(value))}; ', end='')
        print(' Score -> ', score)
    return score
示例#8
0
        else:
            return UnknownMsgType


    all_data_points = {}
    for i, track in enumerate(mid3.tracks):
        # print("--*--" * 20)
        # print('Track {}: {}'.format(i, track.name))
        # print(track,dir(track))
        len_msg = len(track)

        for msg in track:
            global_msg_count += 1
            bytes_p = msg.bytes()

            decoded_msg = str(mido.parse_all(bytes_p))
            # print(decoded_msg)

            msg_type = check_msg_type(msg=decoded_msg)
            if msg_type == MessageFormatter:
                identifier = "M"
                msg_repr = MessageFormatter(decoded_msg)
            elif msg_type == ResetTimerMsg:
                identifier = "R"
                msg_repr = ResetTimerMsg(decoded_msg)
            else:
                identifier = "U"
                msg_repr = UnknownMsgType()

            all_data_points["%s_%s" % (identifier, global_msg_count)] = msg_repr.arr
示例#9
0
 def test_undefined_realtime_inside_sysex(self):
     """Undefined realtime message inside sysex should ignored."""
     messages = mido.parse_all([0xf0, 0, 0xf9, 0xfd, 0, 0xf7])
     self.assertTrue(len(messages) == 1)
     self.assertTrue(messages[0].type == 'sysex')
示例#10
0
 def test_realtime_inside_sysex(self):
     """Realtime message inside sysex should be delivered first."""
     messages = mido.parse_all([0xf0, 0, 0xfb, 0, 0xf7])
     self.assertTrue(len(messages) == 2)
     self.assertTrue(messages[0].type == 'continue')
     self.assertTrue(messages[1].type == 'sysex')
示例#11
0
 def test_undefined_messages(self):
     """The parser should ignore undefined status bytes and sysex_end."""
     messages = mido.parse_all([0xf4, 0xf5, 0xf7, 0xf9, 0xfd])
     self.assertTrue(messages == [])
示例#12
0
 def test_one_byte_message(self):
     """Messages that are one byte long should not wait for data bytes."""
     messages = mido.parse_all([0xf6])  # Tune request.
     self.assertTrue(len(messages) == 1)
     self.assertTrue(messages[0].type == 'tune_request')
示例#13
0
 def test_parse_stray_status_bytes(self):
     """The parser should ignore stray status bytes."""
     ret = mido.parse_all(b'\x90\x90\xf0')
     
     self.assertTrue(ret == [])
示例#14
0
 def test_parse_stray_data(self):
     """The parser should ignore stray data bytes."""
     ret = mido.parse_all(b'\x20\x30')
     
     self.assertTrue(ret == [])