def actOnInput(self, messagesAsTimes):
if len(messagesAsTimes) is 0:
messagesAsTimes.append(time.time())
p = mido.Parser()
while p.pending() > 0:
messagesAsTimes.append(p.get_message())
return 0
def readin_bytes(infile):
"""
Read in messages from a binary mode file object.
Returns iterator over Messages.
"""
data = infile.read()
parser = mido.Parser()
parser.feed(data)
return iter(parser)
def load_file(self, filename):
global PARSER
PARSER = MidiFile(filename)
with open(filename, 'rb') as f:
# read in the binary file as a byte array
ba = bytearray(f.read())
# feed that into mido's parser
p = mido.Parser()
p.feed(ba)
self.messages = []
while p.pending():
self.messages.append(p.get_message())
def read_syx_file_gen(infile, n=1024):
parser = mido.Parser()
data = infile.read1(n)
if data[0] == 0xF0:
while data:
parser.feed(data)
yield from parser
data = infile.read1(n)
else:
line = data + infile.readline()
while line:
text = line.translate(None, b'\t\n\r\f\v').decode('latin1')
parser.feed(bytes.fromhex(text))
yield from parser
line = infile.readline()
def test_encode_and_parse_all(self):
"""Encode and then parse all message types.
This checks mostly for errors in the parser.
"""
p = mido.Parser()
for spec in mido.messages.get_message_specs():
if spec.type == 'sysex_end':
# This is considered a part of 'sysex_start'.
continue
msg = Message(spec.type)
p.feed(msg.bytes())
outmsg = p.get_message()
self.assertTrue(outmsg is not True)
self.assertTrue(outmsg.type == spec.type)
def read_syx_file(infile):
"""
Read in a binary or hex syx file.
Takes a binary mode file object.
(like mido.read_syx_file, but uses file objects)
Returns iterator over mido Messages
"""
data = infile.read()
parser = mido.Parser()
if data[0] == 0xF0:
parser.feed(data)
else:
# get rid of non-space whitespace
text = data.translate(None, b'\t\n\r\f\v').decode('latin1')
parser.feed(bytes.fromhex(text))
return iter(parser)
def __init__(self):
self.backend = mido.Backend('mido.backends.rtmidi')
try:
self.input = self.backend.open_input('QU-32 MIDI Out')
self.output = self.backend.open_output('QU-32 MIDI In')
except:
self.input = self.backend.open_input()
self.output = self.backend.open_output()
print('WARNING - Not connected to sound board!!!')
self.header = b'\xF0\x00\x00\x1A\x50\x11\x01\x00\x00'
self.parser = mido.Parser()
self.last_message = None
self.messages = [None]
self.patches = {
'cesar': 39,
'ruben': 40,
'helen': 42,
'naylor': 34,
'naylor2': 36,
'doc': 34,
'sherrif': 35,
'father': 35,
'woman': 36,
'carlos': 41,
'rfk': 35,
'gray': 34,
'leads': 16,
'choir': 17,
'band': 19,
'fx': 0,
'god': 33,
'tomas': 32,
'usher': 32,
'old': 32,
'dolores': 32,
'fred': 34,
'jim': 42,
'danny': 32,
'charles': 32,
'reporter': 32,
'maricella': 37,
'monica': 36,
'ernesto': 37,
'god': 33
}
def _send(self, message):
if not isinstance(message, SysexMessage):
raise ValueError("Can only send a SysexMessage")
p = mido.Parser()
p.feed(message.serialize())
self._outport.send(p.get_message())
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
msg = Message('note_on', note=60)
msg
def not_test_parse_random_bytes(self):
r = random.Random('a_random_seed')
parser = mido.Parser()
for _ in range(10000):
byte = r.randrange(256)
parser.feed_byte(byte)
LIGHT_OFF = 0x00
LIGHT_GREEN = 0x01
LIGHT_RED = 0x03
LIGHT_YELLOW = 0x05
LIGHT_BLINK_GREEN = 0x02
LIGHT_BLINK_RED = 0x04
LIGHT_BLINK_YELLOW = 0x06
COLOR_MAP = {
"green": LIGHT_GREEN,
"red": LIGHT_RED,
"yellow": LIGHT_YELLOW,
}
parser = mido.Parser()
def get_arguments(argv):
""""Creates and returns the ArgumentParser object."""
argParser = argparse.ArgumentParser(description='APC mini enlighter')
group = argParser.add_mutually_exclusive_group()
group.add_argument("-l",
"--list",
help="List port names",
action="store_true")
group.add_argument("-i", "--input", help="Path to the input file")
argParser.add_argument("-p", "--port", help="Name of the port to use")
parsed_args = argParser.parse_args(argv[1:])
import pdb
data_path = join(
expanduser('~'), 'Downloads',
'maestro-v2.0.0.zip') #'/home/David/Downloads/maestro-v2.0.0.zip'
with ZipFile(data_path, 'r') as archive:
#get the list of files in the archive.
info = json.loads(
archive.read(join('maestro-v2.0.0', 'maestro-v2.0.0.json')))
#split into test, train, and validation sets
test = list(filter(lambda entry: entry['split'] == 'test', info))
train = list(filter(lambda entry: entry['split'] == 'train', info))
validation = list(
filter(lambda entry: entry['split'] == 'validation', info))
#
wav = BytesIO(
archive.read(join('maestro-v2.0.0', test[0]['audio_filename'])))
midi = archive.read(join('maestro-v2.0.0', test[0]['midi_filename']))
wav = wavfile.read(wav)
pdb.set_trace()
midi_parser = mido.Parser()
midi_parser.feed(midi)
#for m in midi_parser: m
#write function/library to convert from midi-messages to piano-roll data
pdb.set_trace()
pass
