About playing sequence of notes and multiple threads

[lambdamusic]

Hello

I've been having a lot of fun exploring Mido, and was thinking to use it as the foundation of an API for real time musical livecoding.

Here's where I got to:

from __future__ import print_function
import sys
import time
import random
import mido
from mido import Message
from threading import Thread

mido.set_backend('mido.backends.rtmidi')
threads = []

notes = [60, 62, 64, 60]

def playnote(note_or_notes, vel, dur, ch=0):
    """abstraction for playing a note"""
    def _play(note_or_notes, vel, dur, ch=0):
        with mido.open_output(None, autoreset=True) as port:
            if type(note_or_notes) != type([]):
                note_or_notes = [note_or_notes]
            for note in note_or_notes:
                on = Message('note_on', channel=ch, note=note, velocity=vel)
                port.send(on)
            time.sleep(1 * dur)
            for note in note_or_notes:
                off = Message('note_off', channel=ch, note=note, velocity=vel)
                port.send(off)
    t = Thread(target=_play, args=(note_or_notes, vel, dur, ch))
    threads.append(t)
    t.daemon = True
    t.start()

for n in notes:
    playnote([n, n+12], 120, 1, 0)
    print("Now I have %d threads.." % len(threads))
    time.sleep(1)

print("Exiting - with %d threads.." % len(threads))

So I was wondering

a) are threads the right way to go about playing multiple notes simultaneously (so that each note is independently defined)? PS I guess ThreadPools could be used to reuse old threads..

b) is there a standard 'MIDI' way of playing a chord? Eg above I try to do that by grouping all on and off messages. Does that guarantee that notes are played at the same time?

.....
            for note in note_or_notes:
                on = Message('note_on', channel=ch, note=note, velocity=vel)
                port.send(on)
            time.sleep(1 * dur)
            for note in note_or_notes:
                off = Message('note_off', channel=ch, note=note, velocity=vel)
                port.send(off) 
......

Thanks in advance for the help - and keep up the good work :-)

[olemb]

I'm happy to hear you're enjoying Mido! This is very encouraging for me. :)

This is just the kind of thing I had in mind when I made Mido. Early on I used it to make little arpeggiators and live sequencers. I also mapped my sustain pedal to trigger notes which was great fun.

To answer your questions:

a) The current version of Mido is not thread safe, but you're in luck! I am just about to release a 1.1.15 where this is fixed. (See issue #49.) I hope to get it out tonight, or if not later this week.

For now send() might still work. It depends on the underlying backend library. I guess if it doesn't crash it works. :)

b) You're sending chords the right way. MIDI can only do one note at a time, but if you send them close enough together it will sound like they start at the same time.

[lambdamusic]

Cool that's good to know - I'll wait for the next release and do more experimentation using threads then!

[olemb]

Sounds good! I'll let you know when it's out.

[olemb]

I've released 1.1.15.

[jmmcd]

Can I suggest to take a look at midiBuffer.py, available here: https://searchcode.com/codesearch/view/13549062/

It has an abstraction for chords (ok, it would be easy to replicate in mido) and it also deals with "out of order" messages, which could be handy for this type of application (maybe others). From the docstring:

"midiBuffer is a wrapper around pyPortMidi, which is itself a wrapper for portmidi, a cross-platform abstraction over native midi drivers. midi drivers require that you send events in
order. from portmidi.h: Do not expect PortMidi to sort data according to timestamps --
messages should be sent in the correct order, and timestamps MUST
be non-decreasing.

this is especially an issue because the NOTE-OFF message for a
currently playing note will block any NOTE-ON messages for
subsequent notes until the current note ends, so you are expected
to hold on to your NOTE-OFFs until you are sure there will be no
more intervening NOTE-ONs. dealing with scheduling in a more
natural "set-and-forget" way requires concurrency (multithreaded
programming), which is tricky, and requires tuning to compromise
between latency and timing inaccuracies. midiBuffer handles this for you."