def play_midieventstream(self, midieventstream):
# We don't start at the very beginning. This to give the sequencer
# a little time to get ready.
t = 30
a, b = self.m_sequencer.queue_tempo(self.m_queue)
self.m_sequencer.queue_tempo(self.m_queue, a, b)
self.m_sequencer.start_queue(self.m_queue)
for e in midieventstream:
if e[0] == 'program-change':
event = alsaseq.SeqEvent(type=alsaseq.SEQ_EVENT_PGMCHANGE)
event.dest = self.m_clientport
event.time = t
event.set_data({'control.channel' : e[1],
'control.value' : e[2],
})
elif e[0] == 'volume':
continue
elif e[0] == 'bender':
continue
elif e[0] == 'note-on':
event = alsaseq.SeqEvent(type=alsaseq.SEQ_EVENT_NOTEON)
event.dest = self.m_clientport
event.time = t
event.set_data({'note.channel' : e[1],
'note.note' : e[2],
'note.velocity' : e[3],
})
elif e[0] == 'notelen-time':
t += int(96*2*4*e[1])
continue
elif e[0] == 'note-off':
event = alsaseq.SeqEvent(type=alsaseq.SEQ_EVENT_NOTEOFF)
event.dest = self.m_clientport
event.time = t
event.set_data({'note.channel' : e[1],
'note.note' : e[2],
'note.velocity' : e[3],
})
elif e[0] == 'tempo':
event = alsaseq.SeqEvent(type=alsaseq.SEQ_EVENT_TEMPO)
event.dest = (0, 0)
event.time = t
event.set_data({'queue.param.value' : 500000 * 60 / e[1],
'queue.queue': self.m_queue})
else:
print e
raise Exception("Not implemented")
event.source = (0, 0)
event.queue = self.m_queue
self.m_sequencer.output_event(event)
event = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_STOP)
event.source = (0, 0)
event.queue = self.m_queue
event.time = t
event.dest = (alsaseq.SEQ_CLIENT_SYSTEM, alsaseq.SEQ_PORT_SYSTEM_TIMER)
event.set_data({'queue.queue' : self.m_queue})
self.m_sequencer.output_event(event)
# make sure that the sequencer sees all our events
self.m_sequencer.drain_output()
def __init__(self, Midi_Port_Name='Nano Basket MIDI 1'):
self.Seq = alsaseq.Sequencer(clientname='Nano Basket')
self.Event = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_SYSEX)
self.Controller = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_CONTROLLER)
self.Port = self.Seq.create_simple_port(name=Midi_Port_Name,
type=alsaseq.SEQ_PORT_TYPE_APPLICATION,
caps=alsaseq.SEQ_PORT_CAP_SUBS_READ | \
alsaseq.SEQ_PORT_CAP_READ | \
alsaseq.SEQ_PORT_CAP_WRITE | \
alsaseq.SEQ_PORT_CAP_SUBS_WRITE)
self.Response_Wait = 0.2
def get_event(self):
if not self._event:
self._event = alsaseq.SeqEvent(_event_type_toalsa[self._type])
if self._type in [NOTEON, NOTEOFF, POLY_AFTERTOUCH]:
data = {'note.channel': self.channel, 'note.note': self.data1, 'note.velocity': self.data2}
self._event.set_data(data)
elif self._type == CTRL:
data = {'control.channel': self.channel, 'control.param': self.data1, 'control.value': self.data2}
self._event.set_data(data)
elif self._type in [PROGRAM, AFTERTOUCH, PITCHBEND]:
# print self.channel
data = {'control.channel': self.channel, 'control.value': self.data2}
self._event.set_data(data)
elif self._type == SYSEX:
data = {'ext': self.sysex}
self._event.set_data(data)
elif self._type == SYSTEM:
data = {'result.event': self.data1, 'result.result': self.data2}
self._event.set_data(data)
elif self._type in [SYSRT_START, SYSRT_CONTINUE, SYSRT_STOP]:
data = {'queue.queue': self.queue}
self._event.set_data(data)
if self.source:
self._event.source = tuple(self.source)
if self.dest and isinstance(self.dest, tuple):
self._event.dest = self.dest
return self._event
def notes_event(self, beat, instr_id, measure_data):
# TODO: take advantage of ports 128:1, 128:2, 128:3
channel = instrument_channel(instr_id)
event = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_NOTE)
start_tm = beat * self.ppq # Beginning of measure, in ticks
try:
base_velocity = self.velocity[instr_id]
except KeyError:
base_velocity = 64
for note in measure_data.events:
ticks = int(4 * self.ppq / note.duration)
if instr_id == 0:
# Don't jitter the metronome!
jitter = 0
else:
jitter_dist = int(32 / note.duration)
jitter = random.randrange(jitter_dist)
if note.pitch != 0:
event.dest = (self.cid, instrument_port(instr_id)) #self.pid)
event.queue = self.outq
event.time = start_tm + jitter + DELAY
veloc = base_velocity + random.randrange(10)
dur = ticks + jitter
event.set_data({
'note.note': note.pitch,
'note.velocity': veloc,
'note.duration': ticks - jitter,
'note.off_velocity': veloc,
'note.channel': channel
})
#print 'event:', event, event.get_data()
self.seq.output_event(event)
start_tm += ticks
self.seq.drain_output()
def alsa_event(cls,
event_type,
port,
channel=0,
data1=0,
data2=0,
sysex=None):
event = alsaseq.SeqEvent(_event_type_toalsa[event_type])
if event_type in [NOTEON, NOTEOFF, POLY_AFTERTOUCH]:
data = {
'note.channel': channel,
'note.note': data1,
'note.velocity': data2
}
event.set_data(data)
elif event_type == CTRL:
data = {
'control.channel': channel,
'control.param': data1,
'control.value': data2
}
event.set_data(data)
elif event_type in [PROGRAM, AFTERTOUCH, PITCHBEND]:
data = {'control.channel': channel, 'control.value': data2}
event.set_data(data)
elif event_type == SYSEX:
data = {'ext': sysex}
event.set_data(data)
elif event_type == SYSTEM:
data = {'result.event': data1, 'result.result': data2}
event.set_data(data)
event.source = (0, port)
return event
def note(n, state=False):
if state:
etype = alsaseq.SEQ_EVENT_NOTEON
else:
etype = alsaseq.SEQ_EVENT_NOTEOFF
event = alsaseq.SeqEvent(type=etype)
event.set_data({'note.channel': 0, 'note.note': n, 'note.velocity': 90})
seq.output_event(event)
seq.drain_output()
def instrument_event(self, beat, instr_id, new_instrument):
event = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_PGMCHANGE)
event.dest = (self.cid, instrument_port(instr_id))
event.queue = self.outq
event.time = beat * self.ppq
event.set_data({
'control.value': new_instrument,
'control.channel': instrument_channel(instr_id)
})
self.seq.output_event(event)
def test():
print('\n==== MidiEventFactory test')
CCMidiEvent.register_event_type_builder()
CCMidiEvent.register()
JStationSysexEvent.register_event_type_builder()
WhoAmIResponse.register()
sysex_data = [
0xf0, 0, 0, 0x10, 0x7f, 0x54, 0x41, 0, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1,
121, 0xf7
]
print('input sysex data: %s' %
['x%02x' % (val & 0xff) for val in sysex_data])
sysex_seq_event = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_SYSEX)
sysex_evt_data = dict()
sysex_evt_data['ext'] = sysex_data
sysex_seq_event.set_data(sysex_evt_data)
factory = MidiEventFactory()
sysex_event = factory.build_from_seq_event(sysex_seq_event)
if sysex_event:
print(sysex_event.is_valid())
print(str(sysex_event))
else:
print('sysex not recognised')
cc_seq_event = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_CONTROLLER)
cc_data = dict()
cc_data['control.channel'] = 1
cc_data['control.param'] = 34
cc_data['control.value'] = 20
cc_seq_event.set_data(cc_data)
cc_event = factory.build_from_seq_event(cc_seq_event)
if cc_event:
print(cc_event.is_valid())
print(str(cc_event))
else:
print('cc not recognised')
def volume_event(self, beat, instr_id, new_volume):
# Global volume
event = alsaseq.SeqEvent(alsaseq.SEQ_EVENT_CONTROLLER)
event.dest = (self.cid, instrument_port(instr_id))
event.queue = self.outq
event.time = beat * self.ppq
event.set_data({
'control.param': 7,
'control.value': int(new_volume),
'control.channel': 0
})
self.seq.output_event(event)
def fill_seq_event(self):
self.seq_event = alsaseq.SeqEvent(self.event_type)
