Connections

Serial and Parallel

A >> B

Chain(units)

Connect units in series. A >> B is equivalent to Chain([A, B]).

Incoming MIDI events will be processed by unit A first, then by unit B. If an event is filtered out by unit A, it is not processed any further, and unit B will not be called.

# transpose one octave down, then set channel to 1
Transpose(-12) >> Channel(1)

[ A, B, ... ]

A // B

Fork(units, remove_duplicates=True)

Connect units in parallel. [ A, B ] is equivalent to A // B and Fork([A, B]). All units will be called with identical copies of incoming MIDI events. The output will be the sum of all the units’ outputs.

# send events to both channels 1 and 2
[ Channel(1), Channel(2) ]
# or:
Channel(1) // Channel(2)

+A

A.add()

Apply A to a duplicate of each event and leave the original unchanged. This is a shortcut for [ Pass(), A ].

Units are always called in the order they appear in a patch, using a “breadth-first” approach. For example, given the patch

Fork([ Port('foo'), Port('bar') ]) >> Fork([ Channel(1), Channel(2) ])

Port('foo') will be called before Port('bar'), and the two events produced by the first Fork() are then passed on to the second Fork() individually. The four events resulting from this patch are thus emitted in the order ‘foo 1’, ‘foo 2’, ‘bar 1’, ‘bar 2’.

Normally, mididings automatically removes identical events that are the immediate result of units being connected in parallel. For example, while [Pass(), Transpose(12)] results in two different events for each incoming note-on or note-off event, it does not produce duplicate controller or program change events, although both Pass() and Transpose() leave those events entirely unchanged. With Fork() it is also possible to disable the automatic removal of identical MIDI events by setting remove_duplicates to False.

Filtering and Splitting

Filter(types, ...)

Filter by event type. Types are represented by the constants described in section Event Types. Multiple types can be combined as bit masks, or given as lists or as separate parameters.

# allow only program and control changes to go through
Filter(PROGRAM, CTRL)
# these are equivalent:
Filter(PROGRAM|CTRL)
Filter([PROGRAM, CTRL])

See section Filters for units that allow filtering by different event properties.

~F

F.invert()

Invert the filter F. Note that for filters which only affect certain kinds of events, other events will remain unaffected when the filter is inverted. For example, an inverted KeyFilter() will match a different note range, but neither the original nor the inverted filter will have any effect on controllers or program changes.

# remove CC events with controller number 42
~CtrlFilter(42)

-F

F.negate()

Negate the filter F. Unlike ~F, this matches exactly the events that F doesn’t.

{ T1: A, T2: B, ... }

Split(mapping)

Split by event type. { t1: a, t2: b } is equivalent to Split({ T1: A, T2: B, ... }), and both are merely a shorter way of saying [ Filter(T1) >> A, Filter(T2) >> B ].

# send note events to channel 1 and CC events to channel 2
{ NOTE: Channel(1), CTRL: Channel(2) }

See section Splits for units that allow splitting by different event properties.

All split units are just combinations of multiple filters of the same type. Tuples can be used to pass multiple arguments to a split’s underlying filters (lists won’t work, as they are not hashable and thus can’t be used as keys in a dictionary). In addition to any filter arguments, splits also allow None to be used as a key. This acts as an else clause that is executed when none of the other conditions match:

ChannelSplit({
    1:      ...,    # if channel == 1
    (2, 3): ...,    # if channel == 2 or channel == 3
    None:   ...,    # else
})

Selective Processing

Every filter can act as a selector that restricts some processing steps to certain events:

S % A

S.apply(A)

Apply A only to events which match selector S, and leave events which don’t unchanged. If S is a single filter, this is equivalent to [ S >> A, -S ].

# transpose only events on channel 2
ChannelFilter(2) % Transpose(3)

S % (A, B)

S.apply(A, B)

Apply A to events which match selector S, and B to events which don’t.

# change notes between C3 and C5 to channel 1,
# and all other notes to channel 2:
KeyFilter('c3:c5') % (Channel(1), Channel(2))

Multiple filters can be combined into more complex selectors:

(S1 & S2 & ...)

And(conditions)

Build a selector for events that match all of the given filters or selectors. (S1 & S2) is equivalent to And([S1, S2]).

(S1 | S2 | ...)

Or(conditions)

Build a selector for events that match at least one of the given filters or selectors. (S1 | S2) is equivalent to Or([S1, S2]).

# change controllers 23 and 42 on channel 1 to channel 2:
(ChannelFilter(1) & (CtrlFilter(23) | CtrlFilter(42))) % Channel(2)