Pure Data OSC test patch

The main new feature in this version is support for Open Sound Control (OSC). After the last version a great offer came from programmer Michael Heuer to collaborate and add OSC support to the application. So this part of the program is very much his work. You can view more of his projects on GitHub.

The application

Euclidean Pattern Generator v1.1

As usual here are some download links for the app and the source files. Note that the application is now released under the GPL v3 license. If you’re a developer you might find it easiest to visit the GitHub repository.

Download Java JAR file.
Download Mac OS X APP file.
Download Java source files (Eclipse project), JAR and APP, all in one ZIP file.
GitHub repository for the Euclidean Pattern Generator.

The OSC implementation

All OSC messages are sent to ‘localhost’ on a port number you can specify yourself. In the top part of the application I added a text input labelled ‘OSC Port’. Here you can enter the port number of the receiving OSC server you want to send the OSC messages to.

Because there is a choice now between MIDI and OSC I added checkboxes ‘Send OSC’ and ‘Send MIDI’. Only when these are checked OSC and / or MIDI messages will actually be sent.

The receiving OSC application is able to identify which pattern sent the message if an address for the pattern is entered.
In the pattern’s MIDI / OSC Settings panel there is a new text input field labelled ‘OSC Address’. This field is automatically filled with a default address ‘/eu/patternX’ where ‘X’ is a number that is auto-increased with each new created pattern. Of course you can use your own preferred address naming scheme as well.

Here is a video that demonstrates sending OSC messages from the application to a Pure Data patch.

Other new features

Next to the Open Sound Control support there are a number of other new features, some of which were requested by users in comments on the previous version.

• Step duration (quantization) from 4 beats (one 4/4 measure) to 1/8 beat (1/32 note).
• Tempo maximum increased to 300 BPM.
• Pattern length up to 64 steps. The pattern grows in size to accommodate the number of step circles.
• Patterns can be named. New text input Pattern name in the pattern’s Other Settings panel. Whatever is typed here appears under the pattern graphic. When there are a lot of patterns in a project it’s easy to lose track of which pattern does what, so now you can name them ‘kick’, ‘snare’ etc.
• ‘All Notes Off’ button to kill hanging notes. This sends an ‘All Notes Off’ MIDI Channel Mode Message to each channel. All Notes Off is actually MIDI CC #123 with value 0 (see the MIDI specification).
• New patterns start with velocity 10 (handy in live situations where you don’t want a new pattern to come in at full volume).
• Preferences: Several settings are automatically stored and recalled the next time you open the application.
  • Window size and position.
  • MIDI enabled and MIDI Out port.
  • OSC enabled and OSC port number.
  • Last used directory to open or save a project.

And lastly, not really a new feature, but ‘behind the scenes’ the user interface now uses SwiXML, a layout engine that uses XML files to define an interface built with Java Swing components. This makes the interface much more flexible and easier to maintain for future changes.

Next version

In the next version I’ll add MIDI input and I hope it will be possible to get the app to synchronize to external MIDI clock. That would be cool.

And I’d like to add triplets to the quantization options. For even more unusual polyrhythms.

Screenshot

Since Flash doesn’t do MIDI I spent the last few months learning Java and rebuilt the pattern generator to add MIDI capabilities.

Running the application

The Java app doesn’t run in the browser, so I can’t show it embedded on the web page like I’m used to with Flash projects. Instead you’ll have to download the Java .jar file and run it on your computer like you would any regular desktop application. For Mac users there’s a OS X .app file as well.
I haven’t looked into creating an .exe file for Windows users yet, but double clicking the .jar file should start up the program just like an .exe.

Download Java JAR file. *
Download Mac OS X APP file.
Download Java source files (Eclipse project), JAR and APP, all in one ZIP file.

* The JAR file needs the runtime for Java v1.6 (also known as Java SE 6) to be installed. On Mac this version is automatically installed with OS X 10.6 (Snow Leopard), but OS X 10.5 (Leopard) has the older Java v1.5 (or J2SE 5.0). I tested on Windows XP with Java v1.6 and that runs fine. You can test your Java version by opening Command Prompt (Windows) or Terminal (OS X) and typing “java -version” (without the quatation marks and press return after typing).

To compensate for the lack of an embedded app here’s a video with a short overview of what the Euclidean Pattern Sequencer does:

Features

The features are basic in this first version:

• Double click anywhere in the lower panel to generate a new pattern. A new pattern is 16 steps with 4 notes by default.
• Click a pattern’s center circle to select the pattern. A selected pattern shows a double center ring and it’s settings are displayed on the panel at the right.
• Drag a pattern’s center circle to move the pattern. So you can visually reorganize your screen when there’s a lot of patterns.
• All patterns with their settings and location can be saved in a file. This is a regular XML text file. The File menu has the familiar New, Open, Save and Save As options. The project tempo is saved in the file as well.

Pattern generator control bar

Pattern Settings Panel

Once a pattern is selected it’s settings can be edited:

• The Steps and Fills sliders determine the pattern. Each time one of them changes the algorithm is recalculated.
• Rotate rotates the pattern. As you’ll note when you play with the Steps and Fills sliders, a pattern always starts with a note on the first step. To overcome this limitation you can rotate the pattern with this slider.
• MIDI settings Channel, Pitch and Velocity are parts of the MIDI Note On and Note Off messages that the pattern sends to the MIDI port.
• Length is the duration of the note. Once the end of a note is reached a MIDI Note Off message is sent to the MIDI port. The length of a note can be 16 steps maximum. At the moment length is measured in the internal sequencer resolution, which is 24 PPQN. Because one step is seen as a 16th note, the maximum slider value is ( 16 steps / 4 ) * 24 PPQN = 96. Not very intuitive, I know. I’ll think of something better in an update.
• Mute, Solo and Delete do what you’d expect them to do.

Examples

Here are two pieces of music I’ve already made with the app. I tried to get them to be a bit more like finished track than just demos of layered polyrhythms.

The first one is the same setup as in the video above but with more patterns. About sixteen of them sending MIDI to sixteen tracks in Ableton Live with mainly samples being played. I recorded the MIDI patterns in Live, did some arranging and automation and exported the result as audio.

Euclidean Patterns Demo 1 by Wouter Hisschemöller

The second one are patterns sending MIDI notes to a hardware drum machine via the soundcard’s MIDI output. This is my new Machinedrum UW that plays samples as well as synthesizing drum sounds. All sounds are the Machinedrum’s sixteen tracks playing and recorded on the computer.

Euclidean Patterns Demo 2 by Wouter Hisschemöller

MIDI

I’d like to put in an XML file all the information about how many patterns there are, how many tracks, which sound plays when and so on. But I want to keep the file as flexible as possible. It must be easy to later change the length of a pattern to 32 tracks, to add melodic patterns, notes of different length, filter settings… Whatever I need I want to be able to include in the file.

Then it occurred to me that such a file already exist: MIDI!

MIDI has been around since 1982, and today still is one of the main formats for music. Besides channels, notes and timing it can hold all kinds of extra settings as “Control Change” values or “System Exclusive” messages. Very general and flexible and just what I need. Only, MIDI is no XML. And Flash can’t read MIDI files. So I googled MIDI and XML and found I’m not the first to need MIDI in an XML form.

As far as I’ve been able to find two standards exist to format MIDI as XML:

MIDI XML

The first one is MIDI XML. The good thing is that it’s been developed by the MIDI Manufacturers Organization which is the organization that made the original MIDI specification. But the bad thing is that it seems to be incomplete and their only page about MIDI XML was last updated in July 2003.

A few DTD pages exist to show how the XML should be formatted, but that’s about it. Not a lot of information. The most interesting DTD file is MIDIEvents10.dtd, which shows how to represent MIDI events. This is what the XML should look like according to the file:

1
2
3
4

<NoteOn Channel="1" Note="60" Velocity="100" />
<NoteOn Channel="1" Note="62" Velocity="127" />
<ControlChange Channel="16" Control="7" Value="50" />
<ProgramChange Channel="1" Number="2" />

Clear enough, but this is only useful for a direct stream of MIDI events. Not to represent a MIDI file with a complete song. If only because there is no time information. You’d never know how much time it takes from one note to the next.

MusicXML

The second one is MusicXML. A much more complete standard made by Recordare, a music and software company I had never heard of before. It seems to build on the MIDI XML standard, but goes much further. This is how an event would be represented in MusicXML:

1
2
3
4

<Event>
  <Delta>0</Delta>
 <NoteOn Channel="1" Note="60" Velocity="100" />
</Event>

The main new thing is the <Delta> tag. It’s value is the time it takes from this event to the next, measured in “Ticks Per Beat”. How many ticks per beat there are can be found in the first section of the XML file. This is from the XML file I use for my drum machine:

1
2
3
4
5
6
7
8
9

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE MIDIFile PUBLIC
  "-//Recordare//DTD MusicXML 0.9 MIDI//EN"
  "http://www.musicxml.org/dtds/midixml.dtd">
<MIDIFile>
  <Format>0</Format>
  <TrackCount>1</TrackCount>
  <TicksPerBeat>4</TicksPerBeat>
  <TimestampType>Delta</TimestampType>

This means:

• <Format> holds the MIDI file type (0 or 1. 2 is not supported by MusicXML)
• <TrackCount> the number of tracks (which is one because a type zero MIDI file can only have one track)
• <TicksPerBeat> is the finest timing precision of the file. I used four because my drum machine has sixteen steps for a pattern of one bar, which is four steps for one beat. I don’t need more precision here.
• <TimeStampType> is the way time is notated. It can be Delta or Absolute. Delta means  time is the amount of time between the current event and the next event, Absolute means the total time between the start of the song and the current event. I used Delta because real Standard MIDI files (.MID) only use Delta time.

Much more information is available at the Recordare MusicXML pages, including DTD and XSD files, FAQ, tutorials and alphabetical index.

Another very helpful page is http://staff.dasdeck.de/valentin/midi. It’s a collection of PHP scripts to work with MIDI. Especially useful is Midi2Xml where you can upload a standard MIDI file which it translates into MusicXML format. It helped me a lot to discover how MusicXML works.