'Join each list in list in to one list.'

listagral = []

for lista in lists:

listagral.extend( lista )

listagral.sort(key=lambda e: e[4]) # order by timestamp

'Supply events to the sequencer.'

global outgoing

event_tmpl = 'events: {:3} in the ALSA sequencer queue, {:3} outgoing, {:3} may be sent, {:3} sent'

enfila_old = 0

while vivo:

enfila = alsaseq.status()[2]

if enfila < 250 and outgoing:

nenviar = 500 - enfila - nlibres

if len(outgoing) > nlibres:

for evento in outgoing[ :nlibres ]:

alsaseq.output( evento )

print(event_tmpl.format(enfila, len(outgoing), 500 - enfila, nlibres))

outgoing = outgoing[ nlibres : ]

else:

print(event_tmpl.format(enfila, len(outgoing), 500 - enfila, len(outgoing)))

for evento in outgoing:

alsaseq.output( evento )

outgoing = []

elif enfila != enfila_old:

print(event_tmpl.format(enfila, len(outgoing), 500 - enfila, 0))

enfila_old = enfila

time.sleep( 0.5 )

'Retrieve received events.'

global incoming, waitingforsplit, split

p = select.poll()

p.register( fd, select.POLLIN )

while vivo:

p.poll( 5000 )

while alsaseq.inputpending():

entrante = alsaseq.input()

nota = entrante[7][1]

type = entrante[0]

if type in rechazados:

continue # discard obnoxious Clavinova events

elif type == alsaseq.SND_SEQ_EVENT_ECHO:

drums( ritmos[ nritmo ], tempo, compases )

continue

ev = alsamidi.modifyevent( entrante, ch=1 )

if waitingforsplit:

split = nota

waitingforsplit = 0

print(nota)

continue # discard note

if not split:

alsaseq.output( entrante )

alsaseq.output( ev )

incoming.append( ev )

incoming.append( entrante )

elif nota > split:

alsaseq.output( entrante )

incoming.append( entrante )

else:

alsaseq.output( ev )

incoming.append( ev )

print(len( incoming ), 'incoming')

'Start playing events.'

global playing, outgoing, incoming

playing = True

incoming = []

outgoing = merge(seq.tracks)

alsaseq.start()

print('playing')

'Stop playing of events.'

global playing, incoming

playing = False

alsaseq.stop()

if incoming:

incoming.insert( 0, pgmchangevoz1 )

if voz2:

incoming.insert( 0, pgmchangevoz2 )

seq.tracks.append( incoming )

incoming = []

print('stopped')

'Output one measure to queue.'

global incoming

tiempoms = alsamidi.tuple2time(

alsaseq.status()[1] ) * 1000

t = pista.construye( ritmo, tempo, compases, tiempoms)

final = alsamidi.time2tuple( pista.duracion( ritmo, tempo, compases, tiempoms )/1000. )

t.append( (alsaseq.SND_SEQ_EVENT_ECHO, 1, 0, 0, final, (0,0), (alsaseq.id(),0), (1,2,3,4,5) ) )

for evento in t:

alsaseq.output( evento )

'Read on letter from stdin.'

global ritmos, nritmo, tempo, split, waitingforsplit

global voz1, voz2, pgmchangevoz1, pgmchangevoz2

if not playing:

if letra == 'p':

playback()

elif letra == 'o':

seq.read( ruta )

print('read', ruta)

elif letra == 's':

seq.write( ruta )

print('saved', ruta)

elif letra == 't':

enabledisabletracks()

elif letra == 'k':

print('hit keyboard split point:', end=' ')

waitingforsplit = 1

elif letra == 'v':

voz1 = int(input())

pgmchangevoz1 = alsamidi.pgmchangeevent( 0, voz1 )

alsaseq.output( pgmchangevoz1 )

print('voice 1:', voz1)

elif letra == 'b':

voz2 = int(input())

pgmchangevoz2 = alsamidi.pgmchangeevent( 1, voz2 )

if voz2:

alsaseq.output( pgmchangevoz2 )

print('voice 2:', voz2)

else:

if letra == 'p':

stop()

elif letra == 'r':

ritmos = pista.lee( 'main.pat' )

for i, x in enumerate(ritmos):

print('{:2} {}'.format(i, x[0]))

drums( ritmos[ nritmo ], tempo, compases )

elif letra in '0123456789':

nritmo = int( letra )

print('{:2} {}'.format(nritmo, ritmos[nritmo][0]))

elif letra == 'n':

number = int( input() )

if number < len( ritmos ):

nritmo = number

print('{:2} {}'.format(nritmo, ritmos[nritmo][0]))

elif letra == 't':

tempo = int( input() )