MidicaPL Tutorial, Chapter 6: Patterns

This chapter explains how to implement and use musical patterns, like finger picking and the like.

Patterns

However this whole code does not produce any sound because the pattern is empty and does nothing with the chords. We will change that in the next section.

Pattern Block

A pattern block contains information what to do with the chord. It can consist of:

• lines producing a compact command (using any combination of the provided notes or rests)
• lines producing a lowlevel command (with a rest, note or sub chord of the provided chord)
• nestable blocks
• nested patterns

Compact commands in a Pattern

Pattern lines that produce a compact command begin with a single : without a channel number. The rest of the line describes notes, chords or rests. But instead of using note names, each single note is addressed by a note index.

The notes in the chord are sorted by pitch, from low to high. The lowest note has note index 0.

Let's investigate the following chord:

CHORD amin a-2 e- a- c e

In this case, a-2 has note index 0, e- has index 1, a- has index 2, c has index 3 and e has index 4.

With this knowledge we change the above 'do nothing' example to something else: The first bar of "House of the Rising Sun". The following two examples are equivalent. The first one uses the pattern, the second one doesn't.

We renamed the pattern from do_nothing to basic because now it's actually doing something. Then we defined what to do with the A minor chord. As we only care about the first bar here, we didn't need more chords so far.

The colors make clear where which part comes from. The channel (marked in blue) is only defined in the channel command 0: amin:basic. The pattern itself doesn't contain a channel. (It could be used from several channels.) The note indices are marked in red. In the second example you see how the indices are translated into notes.

Lowlevel commands in a Pattern

A pattern line producing a lowlevel command consists of the following elements, separated by white space(s):

• note index
• note length
• options (optional)

The following example shows the same pattern as before, but with lowlevel pattern lines. Again the first example shows how to use the pattern, while the second one shows the equivalent lowlevel commands without pattern.

Again, the colors make clear where which part comes from.

Now we want to add the next three bars. So we just add the missing chords again and apply the pattern on them. But we leave the pattern definition unchanged.

We applied the pattern to amin and cmaj from a lowlevel command. But for the next two chords we used a compact command. So you see, this is completely exchangeable.

Our song sounds already pretty well like the original. But if you are really picky and listen carefully, you may notice that only the first two bars are correct. The 3rd and 4th bar need a slightly different pattern. We will implement it with the name alternate - but this time we only use compact commands inside the patterns:

Chords in a Pattern

A pattern can also contain a chord, consisting of more than one note in a line. Instead of comma-separating note names, like in normal channel commands, the note indices must be comma-separated to achieve that. The following examples show how that works. The first example uses a chord inside of a pattern, while the second one shows how this very same thing would look with normal channel commands:

The following example is the same thing with lowlevel commands - first with the pattern and then the equivalent code without pattern:

This pattern is called travis because it implements the famous Travis Pattern, a finger picking pattern named after Merle Travis.

The note indices 0,3, marked in blue, are translated to the chord c-,c.

In order to create the first 8 bars of "Dust in the wind", we only need to add a few more chords and use this pattern with them. We do that in compact syntax:

Barlines in a Pattern

A compact command inside a pattern block can contain bar lines. Here's a rewrite of the dust-in-the-wind example, but with bar lines:

Rests in a Pattern

In order to create a rest inside a pattern, just replace the note index with a dash: -.

The next example shows a small variation of the travis pattern, containing a rest. The first example shows the pattern with lowlevel commands, the second one with compact commands:

Blocks in a Pattern

A pattern can contain nestable blocks. The next two examples are equivalent. The first one uses nestable blocks in a pattern, while the second one shows how this would look without a pattern:

The inner block has a multiple option (m), so the note indices 0, 1 and 2 (notes c-, e- and g-) are played together with note index 3 (note c).

The outer block has the quantity option q=2, so it's repeated twice.

Options

The following two examples show how a chord can be played like an arpeggio, from the lowest to the highest pitch, with a length of a full note and a distance of a thirty-second. The first example uses compact syntax, the second one uses lowlevel syntax:

Inside of the pattern, each note index line has a multiple option (as an inner option, marked in blue) because the notes shall be played "more or less" simultaneously.

But not completely simultaneously, so we need very small rests between the notes.

The whole thing shall still cover exactly a full note's length. So we wrap everything inside a multiple block and add a full note rest at the end.

The line using this pattern has the quantity option as an outer option, marked in red, to play the pattern twice.

Inner Velocity & Duration

There is a perculiarity for velocity and duration, if used as an inner option.

The pattern begins with the velocity and duration values from before the pattern usage (or the one supplied as outer option, if given). When it's changed inside the pattern (as an inner option), the new value is valid until the end of the pattern. After the pattern, the value from before the pattern usage is restored again. (Or the one from the outer option, if given.)

The following example demonstrates how this works. Lowlevel first, then the same with compact syntax:

CHORD cmaj c- e- g-

PATTERN demo
	0  /8
	1  /8
	2  /4  d=40%
	1  /4
	2  /4
END

0  c-    /2    v=50, d=90%
0  c-    /2
0  cmaj  demo  v=95
0  c-    /2    q=2

CHORD cmaj c- e- g-

PATTERN demo
	:  0:8 1 (d=40%) 2:4 1 2
END

0:  (v=50,d=90%) c-:2 c-
0:  (v=95) cmaj:demo (q=2) c-

Everything begins with a velocity of 50 (piano) and a duration of 90%.

The velocity is switched to 95 (forte) in the outer option of the pattern usage (lowlevel example). Or directly before the pattern usage (compact example).

That means, the pattern begins with velocity = 95 and duration = 90%.

The pattern switches the duration to 40% (staccato) with an inner option. (3rd pattern line of the lowlevel example, (d=40%) in the compact example)

After the pattern ends, the duration is restored to 90%. But the velocity is not restored because it has been set with an outer option (lowlevel) or completely outside the pattern (compact). So it continues to be 95 (forte).

Inline Chords

When we introduced note indices, we learned that the chord's notes are sorted by pitch before being addressed via note index. But this is only true for predefined chords. When we use inline chords, the notes stay in the same order as they are written. The following example demonstrates the difference between predefined and inline chords. Lowlevel first, then the same with compact syntax:

We apply the same pattern first to three predefined chords and than to three inline chords. All six chords contain the same notes. Only the order is different.

However the predefined chords produce the same sequence because they are sorted by pitch implicitly. But the inline chords produce different sequences.

With this knowledge we can use our upstroke pattern from above to create an upstroke as well as a downstroke:

Nested Patterns

The downstroke pattern just reverses the given chord and applies the upstroke pattern to it.

But more complicated nestings are also possible. The following example assumes that the previously defined patterns travis, upstroke and downstroke are available. Lowlevel first, then the same with compact syntax:

The pattern main uses the nested patterns travis, upstroke and downstroke.

The nested pattern downstroke uses upstroke as a nested pattern. So we have two levels of nesting here.

Pattern Parameters

Patterns can have parameters, just like functions. Pattern parameters are added in round braces after the pattern name, when using the pattern. They work exactly like function parameters. That means, there are indexed and named parameters.

The following two examples are equivalent. They both rewrite the upstroke pattern so that the note length and note distance are provided as parameters. The first example uses indexed parameters, while the second one uses named parameters:

The pattern contains only compact commands but for using it we use both types. For the first two pattern calls we use compact syntax. In this case, there are no whitespaces allowed in the whole pattern usage like cmaj:upstroke(/1,/8) or cmaj:upstroke(len=/1,dist=/8).

If the pattern is used in lowlevel syntax then whitespaces are optional, as the last line of both examples shows.

Now we can implement a parametrized downstroke pattern that uses upstroke as a nested pattern. So we need to pass the parameters over to the nested pattern:

Again we use compact syntax for the nested pattern call and mixed syntax for the outer pattern calls.

Remeber our "House of the Rising Sun" example above. The two patterns basic and alternate are pretty similar. They only differ in the last three notes. So we can use only one, parametrized pattern.

The following two examples are equivalent. The first one uses this new approach, while the second one is the one from above, just for comparison:

As you can see, the parantheses in the pattern usage are optional, if no parameters are used.

So 0 amin basic and 0 amin basic() are equivalent. Or in compact syntax, 0: amin:basic would be the same as 0: amin:basic().

This is just the same behaviour as in a function call.

Magic Variables

$ALL

Sometimes a pattern only contains a rhythm, and all notes of the chord are playing this rhythm simultaneously. But the very same rhythm can be played with different chords from different channels and a different number of notes or even drum instruments.

In this case you can use $ALL instead of the note indices, like the following example demonstrates. It is taken from "Guillaume Tell", an opera from "Gioachino Rossini". Here we show a very minimal version with only 3 channels in measure 261:

The pattern 8r8r defines a combination that's used from several channels. In channel 5 it's called with a single note. In channel 4 the same pattern is played with 2-note chords. And the percussion channel plays it with a "chord" consisting of three percussion instruments.

$ALL is also useful for nested patterns. Here's an example from the same composition:

The pattern 8ss8ss uses the pattern 8ss which uses the pattern ss.

All these patterns can be used with an arbitrary number of notes because they all use $ALL for playing the chord as well as for playing the nested pattern.

$NC

Let's rewrite our upstroke pattern so that it can be used with different guitar chords. A guitar has 6 strings, so a guitar chord can have up to 6 notes. But it can also have less.

The first of the following examples is the re-written example for a variable number of notes. The second example is the one we already know, but now supporting exactly 6 notes, just for a better comparison.

The following example uses our new upstroke pattern with different chords with a different number of notes:

$REV

Now we also want to have a more flexible downstroke pattern. Let's rewrite it, using our new upstroke.

We use upstroke as a nested pattern and provide all given note indices in reverse order with $REV. Then we play some upstroke and downstroke chords: