Audio Icon (openclipart.org, public domain)

Though I’ll not attend, I’d like to advertise this year’s Linux Audio Conference, “the conference about Open Source Software for music and sound” which takes place from May 1-4 2010 in Utrecht, the Netherlands. Hopefully the programme wets your appetite.

Simple Sysexxer 0.3

I just uploaded Simple Sysexxer 0.3. See its dedicated page for details about download and usage.

The MIDI reception part has been rewritten to use the ALSA sequencer directly. Receiving (and sending) huge SysEx messages (greater than 256 bytes, ALSA’s buffer size) now should work reliably. At least it does with a Korg Z1 Synthesizer (168 531 bytes for the complete internal memory).

Hope you enjoy. Feedback is always welcome. Just drop me a line.

Sliced lemon (openclipart.org, public domain)

To better understand sound synthesis and synth waveforms it is very useful to learn more about Fourier synthesis, the reverse process of Fourier analysis. In the following sections, I’ll try to condense the necessary knowledge as much as possible. I hope this simplification does not produce mistakable results. Otherwise please drop me a line.

A Sinewave

The most simple tone is a sinewave. None of the natural instruments is capable to create one, but the sound of a tuning fork is very close to it. In synthesizers, a sinewave usually is available directly as the output of an oszillator. We do recognize the frequency of this single sinewave as the pitch of this tone.

A sinewave.

More harmonic Sinewaves

To change the timbre of the tone, further sinewaves are added, where their frequencies are integer multitudes of the base frequency. The second partial, for example, just is the sinewave at the double frequency of the base sinewave – the octave. The third partial is the sinewave at the triple frequency – a fifth. The fourth again is an octave, the fifth is a third, the sixth again is a fifth, the seventh is a minor seventh, the eighth is an octave again and so forth. You may be surprised that there are so many “inharmonic” frequencies in a tone, but this model works very well for synthesizing sounds. Those harmonic partials are called the “harmonic series”. An instrument that uses this approach to create different sounds is the Hammond organ:

Drawbar Partials of a Hammond Organ

The nine partials (called drawbars) of a Hammond organ, however, are not enough to simulate any natural instrument or to really create a huge set of different sounds. It is necessary to use even more partials, at least until the upper limit of the audible area was passed. Here’s another example. It’s a sawtooth wave from a Korg Z1 synthesizer. The first 32 harmonic partials are emphasized one after another, so they are clearly audible. Note that the emphasized partials are not added but already contained (and only emphasized):

Partials emphasized by a resonance oscillator

The Amplitudes of Sinewaves

The characteristic of a particular musical instrument is the result of the amplitudes of the partials. Some partials may be nonexistent (zero amplitude), while others may be dominant. Additionally, the tone of natural instruments changes over time. Imagine a piano or mallet tone slowly fading away. The amplitude of the partials decreases, and some will decrease faster than others. Considering the stack of individual sinewaves, both aforementioned requirements mean that it was desirable to somehow influence the amplitudes of the individual sinewaves over time. The Hammond does this by fading out the tone of one of the drawbars. It’s called “percussion”:

Hammond Percussion Partials

Here’s what it sounds like when used to play the organ:

Drawbar Percussion Example

Using a low pass filter (available in almost any synthesizer), one can damp the topmost partials of the aforementioned sawtooth wave:

A Sawtooth wave filtered by a lowpass filter

Inharmonic Frequencies

Until now, it was assumed that the partial tones are integer multitudes of the base sine frequency. Most instruments, however, also produce inharmonic partials – some less, some more. A violin (whose timbre is very similar to a sawtooth wave BTW) has a clear pitch and inharmonic partials will play a minor (but nevertheless important) role. If it comes to bells, drums or cymbals, however, the inharmonic partials will play a more significant role.

Synthesizer sounds will also benefit from inharmonic partials, either applied softly to add some “dirt” to the sound, or to create drum and cymbal like sounds.

Many Inharmonic Frequencies

Noise can be imagined as a tone with many frequencies constantly changing over time. By filtering some frequencies out of the noise, it is easily possible to imitate wind or the roar of the surf. Added to a triangle wave, it is possible to imitate the blowing noise of a real flute. Noise alone can be used to imitate drum like sounds.

Additive vs. subtractive Synthesis

Besides others, two synthesis systems have been described in this posting:

• The Hammond organ provides a (very basic) additive synthesis system, where the amplitude of the first 9 harmonic partials can be altered by dedicated drawbars.
• Subtractive synthesizers provide waveforms which contain lots of partials. Filters are used to remove the unwanted partials.

Further synthesis systems, such as frequency modulation or granular synthesis, are more difficult to understand and use and will thus not be described further in this posting.

Resume

I’d like to repeat some of the most essential portions of this posting:

• The most basic tone we know of is a sinewave.
• Adding more harmonic (or inharmonic) sinewaves alters the characteristics of the tone.
• Dynamic sounds consist of partials whose amplitudes change over time.
• Most synthesizers provide a noise generator to create inharmonic frequencies.
• Most synthesizers provide subtractive synthesis capabilities, where filters are used to alter the amplitudes of the partials. A Hammond organ is a very simple example for additive synthesis.

I hope this posting will help to better understand some of the following postings I plan to write. If not, I did something wrong. Please drop me a line.

Consider you have 2,248 files in a directory, each containing one single sound program for your favourite Z1 synth. You need to load them into the synth individually, listen to them and to sort them in directories. Painful it would be.

Fortunately, all sounds are set to one of 18 predefined categories like guitar, synth hard, synth soft, piano, organ and the like. In the SysEx files, the category is coded into the 26. byte. So it was easy to sort the files into subdirectories using a couple of lines of Ruby code (sorry for the misformatting):



#! /usr/bin/ruby

Dir.glob( '*.[Ss][Yy][Xx]' ) do |entry|
determineCategory entry
end



This language seems to be very powerful. Need to do more with it.

Korg Z1 Panel

I’ve collected a lot of sounds for the Z1 from several web pages. All those sounds now need some sorting and rearrangement. After that, I’ll send them to the Z1, extract the best ones and refine them to my likings.

The Z1 offers 256 internal slots for single sounds (called programs), arranged in two banks, A and B. Inserting a PC card, it can make two more banks directly accessible via a dedicated button.

The card provides much more space (4MB in total), and can host up to 15 so called card areas. Each card area hosts two banks. A card area switch hidden in the global menu lets the user define which of the 15 card areas is accessible directly from the synths front panel. This means that 512 sound programs are directly accessible (256 internal, one card area), while the card can host 3584 further sounds (14 remaining banks).
This means it is possible to have up to 4096 sounds available in the synth.

That’s not a minus at all. It’s simply impracticable to search such a huge amount of sounds for a particular one. Instead one wants to use some software tools to manage the growing sound collection.

However, searching such a huge amount of sounds from the Z1’s front panel is painful. To manage a collection of 2,000 sounds, usually a piece of software gets used. Such tools most often not only allow to rearrange sounds, but also to edit them and to tweak other settings. So I searched the web and found some tools:

• Together with the Z1, Korg released an editor for Mac Os 7.5. I wished I had such a machine left just to have some fun, but even if so, it required some other software to be installed to make the tool usable. As the Z1 was not a commercially successful synthesizer, Korg did not maintain this editor and it won’t run on current versions of Mac OS.
• It seems there was an editor for Sounddiver, but since Emagic was bought by Apple, sounddiver seems to be dead.
• Harmony Central hosts zed which looked promising, at least feature wise. However, I do not know whether it was useful for rearranging sounds. The downloadable demo version has some limitations, and the domain of the developer nooloop seems to be unavailable.
• There’s a demo version of the Korg Z1 Editor 2004. AFAIR it was very limited and the price was much more the last time I visited the page. There was an update in november and it’s just about 14€. Though it’s still a Windows application, whereas I run Linux almost all the time, I think I should give it a try again.
• I used UniversalManager a couple of years ago, a freeware Windows application, when I arranged sounds for the Access Virus synthesizer. The great thing about this small tool is that one can manage two collections for the same synth at a time. This way it is very easy to move sounds from the synth to the hard drive and to stuff others into the synth. The tool is highly configurable via a text configuration file. Unfortunately it seems that it does not fit the Z1 well. Firstly, the Z1 does not support to request individual sounds (instead, it always sends one bank as one huge SysEx package). Secondly, I have no clue whether it supports creating checksums for the Z1 or even not. If you are running one of the supported synths (such as a Waldorf MicroQ or an Access Virus), it’s worth a try.
• Pete Kvitek has written some command line Windows applications to convert sounds from the Prophecy or Triton to the Z1. Three further utilities can split one Z1 bank into individual sounds and merge them back into a bank, or list the names of the sounds in a file. Though I always denied to use wine to get some Windows program to work, I didn’t resist this time. Pete’s tools do a great job: Just arrange the sounds using your computer’s file system.

That’s it so far. A post about sorting the files using Ruby will follow :) .

Simple Sysexxer Icon

The last release of Simple Sysexxer used RtMidi for MIDI input. However, some weird things happend when I tried to receive data from my beloved Korg Z1 synth. Today I have rewritten the MIDI input thread using the ALSA sequencer API.

I hear complaints about the sparse ALSA documentation every now and then. Most people use Matthias Nagorni’s commented example code. I read the code of other ALSA sequencer clients during the last couple of days, and I got the impression that many coders took advantage of the open source principle. Or the other way around: copy and paste is great ;-) . Anyway, I learned some things about C hacking while writing my own code, and I’m getting better reading other people’s code day by day.

Here are some snippets of the code which “works for me”. I inherit QThread for the MIDI in class. From it’s constructor, I invoke the init method to create the client for the ALSA sequencer (sorry for the formatting, Wordpress doesn’t do better):



void MidiIn::init()
{
sequencerHandle = 0L;
sequencerEvent = 0L;
if ( snd_seq_open( &sequencerHandle, "default", SND_SEQ_OPEN_INPUT, 0 ) < 0 )
{
emit errorMessage ( tr( "Cannot initialize the MIDI subsystem."), tr( "Please ensure ALSA is accessible." ) );
}

if ( snd_seq_create_simple_port( sequencerHandle, APPNAME, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_APPLICATION) < 0 )
{
emit errorMessage ( tr( "Cannot create MIDI port."), tr( "Please ensure ALSA is set up properly." ) );
}
}



The run method gets invoked as soon as the thread gets started. The polling code has been stolen from Matthias' examples. Thanks a bunch :) :



void MidiIn::run()
{
recordMidi = false;
int npfd = snd_seq_poll_descriptors_count(sequencerHandle, POLLIN);
struct pollfd* pfd = (struct pollfd *)alloca(npfd * sizeof(struct pollfd));
snd_seq_poll_descriptors(sequencerHandle, pfd, npfd, POLLIN);
while ( true )
{
// Avoid too much CPU load. According to the MIDI baud rate, 4 bytes need at least 1024 microseconds to pass the chord.
usleep( 512 );
if ( poll( pfd, npfd, 100000) > 0 && recordMidi == true )
{
processInput();
}
}
}



Here's the code that does "the actual work". The ALSA sequencer gets passed the client's handle and sequencerEvent, which is a pointer of type snd_seq_event_t. ALSA will set this pointer to the memory address where it buffers the current event. As I'm only interested in SysEx data, I leave the body of the loop in any other case. If it is SysEx data, I copy the actual data over to a QByteArray.

ALSA splits (variable length) SysEx data into chunks of 256 bytes. That's why I check whether the data starts with an 0xF0 and ends with an 0xF7. If so, the package is complete and gets send to the main thread via a signal. Otherwise the loop continues collecting data, informing the main (GUI) thread that a chunk of data arrived. This is needed to inform the user that data still is coming in:



void MidiIn::processInput()
{
do
{
snd_seq_event_input( sequencerHandle, &sequencerEvent );
if ( sequencerEvent->type != SND_SEQ_EVENT_SYSEX )
{
snd_seq_free_event( sequencerEvent );
continue;
}
// Stolen from aseqmm/alsaevent.cpp by Pedro Lopez-Cabanillas
tempBuffer.append( QByteArray( (char *) sequencerEvent->data.ext.ptr, sequencerEvent->data.ext.len ) );

// ALSA splits sysex messages into chunks, currently of 256 max bytes in size
// Therefore the data needs collection before sending it to the master thread
if ( tempBuffer.startsWith( 0xF0 ) && tempBuffer.endsWith( 0xF7 ) )
{
emit eventArrived( tempBuffer );
tempBuffer.clear();
}
else
{
emit chunkArrived();
}
snd_seq_free_event( sequencerEvent );
}
while ( snd_seq_event_input_pending( sequencerHandle, 0 ) > 0 );
}



There are a lot of things that can be improved in this code. Patches are always welcome :) . OTOH it will hopefully give other hackers a good starting point. The code also can be found in SVN. See the files src/MidiIn.h and src/MidiIn.cpp.

Korg Z1 synth

I wanted to try out some sounds for the Korg Z1 which are publicly available on webpages (such as the Z1 Yahoo group). To ease this process, I tried out several tools to rearrange the individual sounds across the various collections.

Unfortunately, either one of the files was corrupted or the tool I used had problems under certain circumstances. Some of the files I sent to the synth have been corrupted, but as the tool calculated a proper checksum, those files have been accepted by the Z1.

At startup, the Z1 loads the sound program A000. Unfortunately I loaded one of the damaged files into this slot, causing the Z1 to endlessly reboot when switching it on. Perspiration! A short websearch, however, helped to solve the problem – the Z1 features an emergency boot. Good luck. Here’s how to do it, but you will loose any user data in the synth:

• Switch it off.
• Press and hold both programmable buttons left of the ribbon control pad (SW 1 and SW 2).
• Switch it on. Release the buttons as soon as the display reads as »Emergency Boot«. The Z1 will now boot the OS from its ROM. All sounds will be set to »Init Prog«.
• To get rid of the damaged sounds, go to the global menu, page one, and disable the memory protection.
• Go one page back and select »Factory Load«. If you are sure that only programs are damaged, switch from »All Data« to »All Program«. Press the button »Enter« twice to reset all sound programs.
• Reboot the device to check whether it is operational again.

This was just an issue of a couple of minutes, but the moment of shock was rather impressive :) .

Electric Guitar (openclipart.org, public domain. Thanks, guys!)

The Korg Prophecy was the monophonic predecessor of the Z1. Unfortunately, both instruments are not patch compatible, so you cannot load sounds designed for the Prophecy into the Z1.

However, Pete Kvitek has written a converter, and some Prophecy patches are available on the Z1 Yahoo Group. There are two files, Z1Prophecy0 and Z1Prophecy1. Each one contains two banks of sounds, a total of 512 patches.
The first one contains some incredible cool sounds, and I spent several joyful hours this weekend playing the Z1. To give you a better clue what the Z1 sounds like, here are some snippets I recorded while testing the sounds. That’s not music at all, just a few notes »hacked into the keyboard«.

I really enjoy the Phonic Helix Board 24 Universal. Using jack, I can easily record audio from any of its inputs using qarecord or timemachine. None of the sounds has been postprocessed. It’s the pure signal as received form the Z1 – including the effects. BTW: The names of the recordings do not match the patch names in the Z1, just in case you are looking for them.

I recorded the files using timemachine in wav format at 96kHz. I then used Audacity to cut and normalize the recordings. I would have used sox as well, but I wanted to have some manual control over what happens, and Audacity features a jack output option (using Portaudio, a cross-platform-audio-subsystem).

Let’s start with a set of pad sounds:

Majestic Pad

Percussive Pad

Silk Pad

Soft Pad

Warm Pad

Yammer Pad

The Z1 features a phase modulation oscillator model, similar to the
frequency modulation used by the famous Yamaha DX-7. The name mainly is different due to legal issues. The results, however are very similar.

FM bells

Of course it is capable of producing all of the old style analoguesque sounds you may expect from a multi oscillator model synth. Here are some traditional lead sounds:

I mog den Moog lead

Classical Saw Lead

Here’s the traditional 5th sound:

Lead 5th

And a similar one, with oscillator sync. This means that one of the oscillators gets restarted as soon as the master oscillator reached the end of its phase:

Sync Lead

The plucked string oscillator model can be used to create guitar or harp like sounds. Admittedly, this recording was not played very well. It more sounds like played by a machine than a human player. I apologize:

Plucked Nylon Strings

The plucked string model also is capable for sounds imitating lead guitars. For the keyboarder it’s always hard to compete with the guitarists. If you want to top a sustained guitar sound, you are in need of a lot of manual work. Except you are using the right synth, of course ;-) :

Plucked String Lead

Here’s a sound using the reed model. The physical models of the Z1 are very good in imitating overblown respectively clipping sounds:

Hard Flute

Here’s another example with some clipping tendencies:

Hard lead

This clipping even is possible when using the string model. Here’s a medieval like sound. Note that the first few and some of the last notes sound one octave too high – unintentionally:

Medieval String

And finally, here’s the guitar killer ;-) . The sound came directly from the Z1, with no further processing applied. Admittedly, I used the touch pad controller excessively to make it sound what it sounds like:

Super hard guitar killer lead

That’s it for today. I hope you liked the show. I will surely post more elaborated examples in the future.

The Minimoog provides three ocillators. The third one often was used to apply a vibrato to the sound. A vibrato effectively means to modulate the pitch of the main oscillator(s), thus called frequency modulation aka FM.

Most modern synths provide two, three or even more LFOs which can be routed to almost arbitrary destinations, not only to the main oscillators’ pitches. Use cases often found are filter cutoff modulation, volume modulation (aka tremolo), panorama modulation and the like.

LFOs basically offer similar waveforms as the main oscillators. The most important ones are sine and triangle waves. Most often also sawtooth and squarewaves are supported. Special waveforms include random and sample & hold waveforms, the latter one more or less being a random waveform as well.

Some synths provide the aforementioned basic waveform as additional exponential waves, granting less synthetic sound changes. For the same reason the LFOs’ waveforms can be changed concerning their contour (Access Virus) or to modulate the symmetry (Waldorf Microwave I), to give the sound more living and breathing.

LFOs often provide a fade in time. Some machines allow the LFO 1 to sync each other to put them into the same phase. Additionally modern synths offer sync capabilities to the MIDI clock, so the LFOs can perform modulations according to the speed and rhythm of a (software) MIDI sequencer.

The speed of LFOs often is less than the audible range. However, modern software synths provide speeds which clearly reach the audible area. This allows the creation of interesting sounds using frequency modulations of the main oscillators or the filter cutoffs.

Using LFOs is a complex topic and a source of endless hours of joy and pleasure. It heavily depends on the type of sound to create how to use them. Thus this posting remains what it is: a bird’s eye view on LFOs. I will share some detailed usage in future posts.

ZKM 20091024 - Dieter Torkewitz

The second (and fourth) performance was played on a reacTable by Günter Geiger (on the right hand side. The table in the center is a projection of an overhead camera):

ZKM 20091024 - Günter Geiger

The third piece was called »Blautopf« (which is a lake in southern germany) and performed by Heiko Plank. He played a special, self-developed instrument with a solid wooden body and several strings. He used his very own name for the instrument – »Plank«:

ZKM 20091024 - Heiko Plank

After the concert, the audience was invited to play the reacTable – at reduceed volume though ;-) . The media museum hosted at the ZKM bought such an instrument and plans to put it at the exhibition – in operational state, of course, so visitors can use it to make noise.

It consists of a table which gets read by and used as a display of a computer inside it (a Mac Mini BTW). At the borders of the table, there are various geometrical objects like cubes, rectangels with rounded corners and stars. Those objects can be put on the table, where they are immediately recognized by the computer and put into the audio flow. The computer then puts touch-screen-controls around them which can easily be used to influence the behaviour of the object.

The object types include sound generators like classical analogue synth modules or sample players, modifiers like filters and triggers to create rhythmical sequences. Turning an object also influences its behaviour, depending on its type. It also is possible to change the sound of a module by drawing the desired waveform with the fingers directly on the table. Wicked stuff. Here’s a closeup pic of the instrument:

ZKM 20091024 - reacTable

A very interesting instrument indeed. I didn’t play it myself as it was crowded by several rows of interested people. I will try it out as soon it is installed at the media museum.