Music Downloads

Please notice: All music and lyrics are copyright © 2004-2009 David K. Cornutt. Downloading for non-commercial use is free. You may make copies and redistribute for non-commercial use, provided that you maintain the Source Code name and the song title. Sampling/remixing is welcome, but please contact me first at cornutt @at@ hiwaay .dot. net (apply approprite de-munging).

In the column below, for those of you still stuck with dialup Internet access, download times are given as averages for a typical 128K DSL service. (Yes, I finally changed it from times for a 56K dialup.) Cable modem or ISDN will of course be considerably faster. If you want to just load the song to disk instead of playing it, right-click (PC/Linux), command-click (Mac OS9), or control-click (Mac OSX) on the link and select the appropriate option from the pop-up menu.

Songs

The heliopause is a boundary in space where the solar wind from our Sun dissipates into interstellar space. It is, in a quite literal sense, the outermost limit of our solar system. The two Voyager satellites, launched in 1977, are expected to approach this region soon; they will be the first man-made objects to pass through the heliopause. As of August 2004, there is some controversy in the scientific community about whether Voyager 1 (the farther out of the two) has reached the beginning of the heliopause region.

The song is a musical version of the Voyagers' journey. The first part of the song represents launch from Earth and escape from Earth's orbit. The second part represents the passage past Mars and through the asteroid belts. The third part represents the journey past the outer planets, where both Voyagers took pictures and data from Jupiter and Saturn, and Voyager 2 went on to visit Uranus and Neptune. The last part of the song represents the approach to the heliopause. What will the Voyagers find there?

This song began with some noodling around with a pad patch that I did with the JD-800 on New Year's Day in 2001. Sometimes ya just gotta fire up a pad patch and play some chords. It's good for the soul. I recorded the noodling in the sequencer and then promptly forgot about it for over a year. Early in 2002, while installing a Metro upgrade, I went through some old files and found the pad part, and I started layering various sound effects on it. Almost immediately the idea of the musical journey of the Voyagers came to mind. From there, the song itself came together fairly quickly, but getting a good mix on it proved difficult. At the time, I was still recording on the Fostex 4-track and mixing down to a Teac cassette with Dolby-C. When I tried to mix this, I discovered that the "sss-sss-sss" sounds in the outer-planets portion of the song caused filters in the Dolby-C to open up, with a very audible effect on the tonality of the base pad sound. I tried several things, but the only thing that got rid of the effect was to turn off the noise reduction. Of course, that promptly made the noise go up to an unacceptable level. That was the moment when I became convinced that I needed to go to hard disk recording. Subsequently I acquired the MOTU 828 and I finally got a good mix of this song. (Even so, the version that you hear here, mixed in February 2004, still has a bit of clipping in the second segment. I'm going to mix this again... sometime...)

The basic pad patch is the JD-800, as I said above; I took the simple sequence that I recorded in 2001 and expanded on the harmony and the melodic progression to get what you hear now. The rocket-launch whooshes are a basic noise patch with filter sweep, programmed on the Juno-106. The odd solo sound in the second section was one of my better moments. First, the patch is a sort of L/A thing done with the Proteus/2, combining parts of harp and violin waveforms. Secondly, most of the solo is played in a made-up scale which has a three half-step gap at one point. (I'll post details later.) The chime sounds are all out of the JD-800.

In the third segment, the peculiar chime sound is another noise patch on the 106, but this one is done with the filter turned up to very high resonance. It also uses the 106's built-in chorus. That combination makes it very hard to control the levels, and I was never able to record it properly until I got a good compressor (dbx 266XL). In previous mixes of this song, I had it going through a delay which was panned to the opposite side; that always sounded a bit harsh and I took it out of this mix. However, if I mix this again, I might put it back in -- it sounds more spacey this way. The fourth segment contains a number of noises derived from the Proteus/2. The tones that end the song are a self-oscillation patch on the 106.

This song resulted from some experiments that I conducted with the Hewlett-Packard function generator in the winter of 2003-04. The "nightmare" noises all resulted from a single complex meta-patch involving the JD-800, the S-750 sampler, the Juno-106, a Moogerfohger filter box, the EML 101, and the Midiverb. Here is a conceptual block diagram of the patch:

The source audio consisted of a mix from the S-750 and the JD-800. A low-frequency drawn waveform with severe filtering was set up on the sampler, and combined with a random-note patch from the JD. This mixed audio went into the modulation input on the function generator, which was configured for amplitude modulation of a triangle wave carrier at about 8 KHz. Since the function generator has no VCA, a separate mechanism was set up to control the sounding of the notes (or what passes for notes in this song...) A near-sine-wave patch from the 106 went into the audio input of the Moogerfogger, whose envelope follower was used to produce a control voltage output. (The actual filter in the Moogerfogger was not used.) The control signal modulated the VCA in the EML 101, which controlled the level of the audio. When I recorded the Juno-106 part, I did it without reference to the audio it was controlling, and the results were, well, interesting. In a few places, you can hear some very rapid level fluctuations which resulted from very low noted being played on the 106, causing the envelope follower in the Moogerfogger to "chase the waveform" (the envelope follower switch on the Moogerfogger was intentially set to "fast" to aggrevate this). To top it off, the resulting audio was piped through the Midiverb II, which was programmed to do a huge number of patch changes during the piece. (One reason I keep this old Midiverb is because it can switch patches instaneously without glitching, something that most current effects units lack.)

The bell sounds are a bit of additive synthesis work done with the Proteus, using its sine-combination waveforms. These went through the Lexicon which was set up with a stereo pitch shift patch, with different values on the two channels. The stereo output of this was recorded and then played back with many instantaneous reversals of the stereo panning. In the last part of the song, the bell sounds are a celeste patch on the Proteus and the pad is from the Juno-106. The pitch bends started as an accident. I had intended to use a feature of the 106 which allows the bend lever to be used for control of the filter cutoff to do a "filter fade", a standard trick on the 106 for me. But one time when I played back the MIDI, I accidentally left the bend level pitch control on and it did the pitch bends. I thought that it suited the general feeling of being on knife-edge between asleep and awake, and left it in. The fan noise is an old Sears oscillating fan, recorded on tape using the Fostex and transferred to disk.

I took a crack at trying to compose a waltz for the ballroom dance club that my wife and I dance at. I've gotten mixed comments on the results. Some dancers have told me it's too slow, although I think it's a good tempo for silver American smooth waltz, which is what I intended it for. Most of this song, other than the percussion, is the JD-800. I had originally set this up as a totally virtual mix, but the JD was running out of voices at one point during the first solo. So I soloed the pad and recorded it as its own audio track; then I muted it and recorded everything else to another audio track, and mixed the two. The percussion is the DR-202.

The second solo is a layering of a JD-800 string patch with the Proteus. The string patch's amplitude is modulated using a combination of the two LFOs running at close to their maximum rates, giving the patch a somewhat "nervous" quality. The second layer is the "Section Winds" factory patch from the Proteus. The two parts jump back and forth from playing in unison to playing in intervals, and the combination of some of the intervals gives it a certain Eastern flavor -- hence the title. That layered solo came about as a happy accident, actually. I had a solo played on the JD-800, with a different patch, but it wasn't happening. While playing around with the Proteus, trying to come up with another sound and another solo, I listened to a playback of the second solo without muting the first one, and I heard the intervals happening. After substituting the JD-800 nervous-string patch for the original patch, the final result basically just fell out. I had to make myself leave it alone, because I didn't want to go nuts with it, and the song length needed to be kept to something reasonable for a ballroom dance.

The mix is admittedly rough. I plan to remix this after I get my studio set back up in the new house. In the meantime, I'm putting this version up here so that some of my ballroom friends can give it a listen.

A bombastic tribute to one of our favorite '70s metal bands. In the spirit of the original, my basic rule for this track was, "If it makes noise, I'm putting it in!". Although it was hard work putting it together, this was a fun track to do. And it finally gave me a good excuse to put my Jon Lord impersonation into a track.

Oddly, this song began with something completely different. At a concert of the Huntsville Symphony Orchestra one night, I was struck by the bass tonality created by having the cellos double the bass line one octave up. I attempted to re-create this using the solo cello and double bass samples on the Proteus/2. It didn't work. I'm not sure why. I didn't hear the tonality that I heard at the concert; rather, I heard something that sounded like a not-very-good pair of cello and bass players making a lame attempt to play the same part. Anyway, out of frustration, I played some quick keyboard runs unlike anything a real cellist would be likely to play... and this bass pattern came out, and for some reason, it sounded exactly like the sort of thing Deep Purple would do on one of their more prog days. Everything that happened after that was inevitable...

One of the things I had to work on for this song was my drum beats and patterns. The drum tracks on this are far more involved than anything I've done previously. Most of the pattern drums are coming out of the DR-202, but the one-shot noises and things are from all over. The gong is from the Proteus-2. So are the fast runs of percussion sounds near the end of the first verse. To produce those, I set the Proteus to its "Percussion 1" factory patch, which contains a number of drum and percussion sounds mapped to specific keys. Then, I ran the mouse up and down Metro's on-screen keyboard. It produced a very strange pattern of sounds that I found I couldn't duplicate using either a real keyboard or a programmed sequence. I sampled several of these runs for use in the song. The flanged cymbals and hi-hat sounds are from the DR-202, using its onboard flanger.

The "frying egg" noise bursts stemmed from some attempts (only partially successful) at creating China cymbal sounds with the modular. (In the '70s, no self-respecting drummer went on stage without a China cymbal. I think they did that mainly to see who would ask "Hey, why do you have that cymbal mounted upside down?") The erzatz cowbell was a sample of a tin can (Del Monte whole green beans). As appropriate for something trying to cop the feel of a '70s piece, the drums (as well as most of the rest of the mix) went through a plate reverb algorithm on the MPX-500. (Normally I would use something more subtle, but if you're going to go for bombastic...) However, this really muddied up the kick drum. To get rid of this, I had to separate the kick drum from everything else. Unfortunately, the DR-202 doesn't provide separable output for different drums; everthing comes out the same stereo pair. The only way around it was to solo the kick drum, bypass the reverb, and send it to its very own audio track to be mixed in later.

I like the results. It's the first full-up drum track I've ever done that I've been reasonably happy with. I've still got a lot to learn at programming drum tracks, but sometimes I managed to come up with things that were unlike anything a real drummer would do, but were nonetheless interesting. In particular is a bit after the end of the organ solo which, just as it appears to have gone totally off into the weeds, manages to get back in the groove just in time for the end of the song.

And about that organ solo... Although I do have the A100 at my disposal, for this solo I used a patch on the JD-800. The patch starts with a simple layering of four sines, which by itself does a reasonable Hammond impersonation. Add the JD-800's distortion, spectrum enhancer, and chorus effects, and that's the basic patch. One problem I had with this was the JD-800 has a limitation that the distortion and enhancer effects can only be used when the synth is in single-timbral mode, so the solo had to be recorded as a separate audio track.

What you hear is a splice of two different takes. I did one take which I thought was very good, but it was too long. (At the time, although I knew how I wanted the song to end, I didn't have a concept of how I was going to get there. When I recorded the solo, I had the sequencer set up to just loop the bass and drums indefinitely as long as record was on.) I wound up using the first half of that, and punching in a second, shorter bit at 2:48 to take it home. This bit in turn wound up going in a slightly different direction than I had thought originally, and I subsequently had to re-do the bass line in the second half of the solo to support it. The solo was recorded as MIDI, but I did not edit any of it. Promise.

I don't have a Leslie, so the rotary speaker effect was done with the MPX-500. To add this, I played back the solo's MIDI and ran the JD-800 through the Lexicon. I had a preset selected that could take a MIDI CC message to select between a fast and a slow setting, with appropriate transitions so as to simulate the acceleration and deceleration of the rotating parts in a Leslie going back and forth between the "tremolo" and "chorale" settings. I plugged a Roland foot pedal switch into the MIDI interface and programmed it to generate the CC messages. As the track played back, I punched the pedal to change speeds as a Hammond/Leslie player would. The result went to its own audio track, which got mixed in later.

Solar Cycle 24 began in March 2008. As I write this, Cycle 23, which began in 1996, is about to end. Each cycle lasts about 12 years. Cycle 23 had two sunspot/flare activity peaks, in mid-2000 and mid-2001. The latter in particular is thought to have disabled at least one satellite, and possibly caused a widespread power outage in North America.

The beginning and end of the cycle being the quiet periods, the piece is constructed accordingly. Parts 1 and 5 are both statements of a theme, played in near-unison using flute-like patches on the K5m and the Juno-106, and processed through a rotary speaker algorithm on the Lexicon. There is some MIDI tweaking of the rotary speaker algorithm's parameters throughout, particular in part 5. The 106's patch contains white noise and a very high filter resonance setting, just short of self-oscillation, in a region where the filter is very unstable. This accounts for the whispery, whistling quality.

Part 2 started out as a nod to Jean Michel Jarre, with the pulsating bass line and the string patches that are somewhat reminiscent of Jarre's early work. It contains five verses, each repeating the same chord progression. The bass is from the 106; the string sound is from the JD-800. The modular gets a workout here; it accounts for the noise at the beginning and most of the noises that weave in and out of the second, fourth, and fifth verses. There are two different modular patches at work here. One features the MOTM-101 sample and hold, driving the cutoff frequency of a filter which is processing noise. The S&H is in "track" mode, in which it follows the signal being sampled while the trigger is high, and holds when the trigger is low. Driving it with a pulse-width modulated LFO, and tweaking the slew control througout, produces the various effects. The second one is the clicking-noise patch, created by setting up a MOTM-410 triple resonant filter with high resonance, and exciting it by feeding it pulses. Two other filters and a Cynthia StereOSpace were used to create the stereo effect. A third noise patch was created using the EML 101.

The sort-of piano part in the second and fifth verses is from the Matrix-1000. It's actually a self-repeating patch, but you have to listen close to hear it. This goes back to my very first take on this song, where the second verse had a more complex melody played using a bell-type patch on the JD-800. With that original version, I never worked out what to do with the last four bars of the verse. Eventually, out of frustration, I took it out. Much later, it came back in a simplified form and with the much softer, more mysterious M1000 patch. The noises in the third verse are from the S750 sampler. Two basic samples are at work with various treatments: a sample of a piece of lead crystal being struck, and a voice sample. The voice sample is my own voice; finally, vocals! Well, sort of.

The modular gets another workout playing the solo in the fourth verse. I was going for a lead patch that would sound something like what Derek Sherinian would use, and I think I got it. The sound is from a Q106 VCO being soft-synced and pulse width modulated. The Q106 is running at a constant frequency; the pitch is from the sync source, which is an MOTM-440 VCF set to self oscillate and being driven by the pitch CV (from the JKJ CV-5). The PW modulation is a mix of an LFO and a slowly changing random signal. I had a problem with the PW mod, depending on the random source and the note being played, occasionally being driven to 100% which resulted in a flatline DC output from the VCO. What I wound up doing was first recording the solo as MIDI, and then playing it back while I rode the PW control on the Q106 to keep it out of the over-modulated region, and recording the audio from that. Still, there are a couple of dropouts that got past me, but I left them in because they make the solo a little more unpredictable. Limiting also was added to keep the peaks under control. The solo itself is the complete third take, with no punch-ins and no MIDI editing.

The fourth and fifth verses have drum tracks, which is an area that I'm still working on. To give it a bit of a retro sound, I used some 1980s-ish samples of Synare and Simmons drums from the JD-800, and mixed these with drums from the DR202. The DR202 tracks were hand played on the MPD-24, and the JD-800 drums were played on the JD-800's keyboard. I decided not to quantize the drums, although I did move some notes that were way off on the MIDI display. I tried several things for cymbal tracks, and wound up taking them all out.

Part 3 was a departure for me composition-wise. Usually, my songs are based on an idea for either a melody, a chord progression, a synth sound or timbre, or sometimes a title. This bit was based on a rhythm idea: a 9/8 bar divided into a six-beat "call" and a three-beat "response". However, any comparison to, say, Dixieland jazz ends there -- this song, with its very strict tempo, is much more like something you might find in one of those old Warner Bros. cartoons where Porky Pig has 1950s-style home automation installed in his house... The title "Magnetic Revolutions" alludes to the fact that the Sun reverses its magnetic poles each solar cycle.

The part starts out with an introduction in which a software additive synth, Minky Starshine, plays a two-note melody while while DR202 percussion builds in the background. The noise at the beginning is from the modular, and features the use of the MOTM-510 Wave Warper. The intro breaks into the main concept of the piece, in which a six-note figure from the Matrix-1000 (one of four patches, selected randomly) is answered by a three-note (usually) response. This first "verse" ends with a reprise of the intro, and then is followed by a second longer "verse". In the first verse, all of the three-beat responses are handled by the JD-800 playing a patch which allows quarter-tones to be played. (The normal interval between adjacent keys of a keyboard instrument is a half-tone, so the quarter-tone scale allows playing notes that are "in between" the notes on a piano or other conventional keyboard.) Throughout, a wandering violin appears and disappears. The violin is from another piece of software, G-Force's M-Tron, which is a Mellotron emulator. M-Tron comes with a large number of Mellotron sound banks; this particular violin is from an set originally done for the rare M300, which is seldom heard.

The reprise of the intro offsets Minky Starshine and the percussion with an appearance by the Kramer Duke headless aluminum-neck bass. This is run through the modular, using an old DoD fuzz box as a preamp. Most of the effect comes from the MOTM-410 triple resonant filter. The modular bass sound appears again, backwards this time, and launches the second verse. The second verse has more variation than the first; nearly everyone gets into the act doing the responses, including the TG33, the modular, Minky Starshine again, the EML, and the Proteus/2. Oddly enough, the Juno-106, which is usually a mainstay for me, makes only a cameo appearance; it plays the very last bass note.

Nearly all the rest of the bass notes in the verses come from waveforms originally generated by Csound. I set up a score file to play a C-to-C chromatic scale of bass notes, each several seconds long, using my VCDO code. The scale was repeated with six different combinations of parameters. From the resulting output, I cut and pasted snippets of waveforms chosen from appropriate notes into the track, using Metro's audio fade commands to shape the envelope on each note. It was tedious, but the way the bass line moves from timbre to timbre made it worth the trouble. Occasionally, the Matrix-6r gets to play a few bass notes here and there.

Part 4 is the oldest part of Solar Flare, and is the only part that I managed to complete prior to the move from our old house. That was because it consists of a single take from the EML, going through the MPX500 using a large-hall reverb, with the reverb time turned up to 30 seconds -- the maximum available. The sample-and-hold on the EML is sampling a sawtooth wave from OSC 1 in LFO mode as I hold a note and occasionally move up and down the keyboard, playing in the duophonic mode at times. As it plays, I advance the rate of both the LFO and the S&H's internal clock oscillator, producing various up or down scale effects. I also advance the regeneration on the MPX500 until it eventually breaks into runaway, which produces the roaring effect. The overall feeling is that of a solar storm, in which flares eventually burst into an explosion of particles and radiation that bombards Earth, and every other planet in the Solar System. What effects do they produce on Venus or Mars? How do they interact with Jupiter's electromagnetic environment and its moons? How do they potentially disturb Earth's long-term weather? So much remains to be discovered.

Part 5 wraps up the end of Solar Cycle 24 and previews the beginning of Cycle 25. It's basically a reprise of Part 1. Near the end, the Juno and the K5m break away from unison and some vamping takes place, with additional tweaking of parameters on the MPX500.

Solar Flare has been a fun piece to do, although it has taken up a lot of my time... if any more ideas for five-part extravaganzas pop into my head, I think I'm going to ignore them for a while.

Title	Length	File Size	Format	Bit Rate	Download Time
Gymnopédie #1	2:21	3.3 MB	MP3 stereo	192k VAR	3:40

This is the first "cover version" I have published. It's my version of the well-known composition by the proto-modernist French composer Erik Satie (1866-1925). I did this version of the song as a piece of music for a ballroom dance exhibition routine, to be performed by my wife and myself in a showcase event in February 2009.

Satie did a lot of things in threes, and this composition is the first of three Gymnopédies he wrote. All three were written in 1888, and the first and third were published that year, but for some reason the second was not published until some years later. So what is a "gymnopédie"? It's hard to tell what Satie meant by the word; a literal transation amounts to "foot exercise", which would suggest it was intended to be a dance piece. However, the word does have several other connotations, and since Satie was known to have an expansive and rather wicked sense of humor, the title may have been an inside joke or pun of some sort. One thing that puzzles me is just what kind of dance may have been intended. The Gymnopédies are all in 3/4 time at rather slow tempos, which suggests a waltz, and in fact they work well for contemporary slow waltz. Problem: the slow waltz was unknown at the time. It wasn't invented until about 1900, and it first emerged in the New England area of the USA. The waltz that existed in 1888 was the Viennese waltz, which is done at a considerably faster tempo. This may have been another bit of humor on Satie's part, to write a piece to be passed off as a waltz, but impossibly slow for Viennese waltz.

Although the Gymnopédie #1 was written for piano, it is often performed today by ensembles including classical guitar. (John Williams, for instance, is a fan of the Gymnopédies.) In this version, I've straddled that line by using a guitar-like synth patch to carry the basic melody. The lead line is a flute patch, which is also in line with how the piece is often performed. Although I didn't want to make the piece too "electronic-sounding" so as not to startle or distract the intended audience, I did indulge myself a bit with the countermelody in the second verse. The synths used, in order of appearance, are:

• Guitar sound: V-Synth
• Flute sound: Juno-106
• Bells: JD-800
• Strings: Matrix-1000
• Wind chimes: Proteus/2
• Vocal-like countermelody: JD-800
• Bass: Morpheus

Title	Length	File Size	Format	Bit Rate	Download Time
Remove Before Flight	6:29	10.7 MB	MP3 stereo	192k VAR	7:00

This is Part 1 of something I'm calling the "Flight Trilogy". It is also my first attempt at electronica. It's done in a more or less trance style, although you will find no supersaws here. I wanted to put some song structure on it, and stay away from some of the cliches of the genre. Which is why there is no ducking of the kick drum (in fact, there is no kick at all), no 303-style bass, and no running the whole mix through a filter.

What to say about this? Well, the title refers to something you see in aviation and space hardware. Whenever there is something attached to the airplane while it's on the ground that is not supposed to be there when the plane flies, a red ribbon is attached to it with the words "remove before flight" on the ribbon. Before takeoff, one of the ground and flight crew's responsibilities is to walk around and look for any such ribbons. It's part of every pilot's "walk around" before they get on board.

This starts off with a drum pattern from the DR-202 drum machine, which runs through the whole piece. A low tom sound takes the usual role of the kick drum -- I don't like the kick cluttering up my bass. Speaking of which, there are three bass tracks here. The first one you hear is from the Kawai K5m; the very bottom-ended one is from the JD800, and the one in the "chorus" sections is the V-Synth. The main lead and chord synth is the Matrix-1000; it is sometimes overlaid with a high string sound from the JD990 that is run through an Encore Electronics frequency shifter. The up-and-down arpeggiation is the Juno 106. The Matrix-6r added some noises.

One of my goals for this was to get the Discombobulator modular synth involved, so there are two sections of modular noises. The first section consists of a 3-op FM patch with on-the-fly knob tweaking. No keyboard or VCA was used; I just let it run for several minutes and recorded the results. Then, I excerpted various pieces of it and inserted them into the first quiet section.

In the second quiet section, I set up a patch featuring the MOTM-650 MIDI/CV interface, and the MOTM-510 WaveWarper. The 650 is in duophonic mode with each channel driving one VCO; those two are fed into the X and Y inputs of the 510. A third VCO is driven by a sample-and-hold and goes into the Z input of the 510. I play two-note chords with each note randomly driving one of the two VCOs, with very atonal results.

Also featured is something I call the "drum console". This consists of a Monome 40H (64 keys, in an 8x8 matrix) driving a Csound program loaded with eight drum/percussion samples. Each sample maps to one row of the Monome. The Csound code pitch shifts the sample based on the left/right position of the Monome key played, which effectively turns each sample into a semi-tuned instrument. Since the Monome is not velocity sensitive, a separate Korg Nanocontrol is used to control velocity and stereo pan for each sample. I plan to add more control capabiity to it, but this is what I had for the recording of this song.

I also included some Shepherd tones. I generated these with a Csound program. It runs eight sine waves at a time, at one-octave intervals; as one reaches the upper end of the audio range, it fades out and a new one fades in at the bottom. The output went through a stereo phaser plug-in for additional spatial effect. It's pretty weird to listen to by itself..

There were quite a few tracks here, and most of them were virtual mixed -- recorde as MIDI tracks and the played back all together, with the resulting audio being mixed directly to two-track. The FM noises from the modular had to be pre-recorded because of the way I did them, and because that patch had to be torn down to do the WaveWarper patch. And I wanted to keep the Shepherd tones in the digital domain. So these tracks were added to the mix in the box after the two-track was recorded. On the other hand, although the drum console audio also came out of Csound, I recorded that as MIDI and during the MIDI playback I took its audio from the interface and routed it to a pair of spare channels on the mixer. So it went out of the digital domain to analog, and back again.

Statescapes

Statescapes are works built around the principle of, as Robert Fripp puts it, "repetition and hazard". The basic principle is sound-on-sound; it involves playing improvised parts into a long-period delay (>2 seconds), and using the built-up repetitions created by the delay as background for additional parts. This proceeds until the end -- whenever that is! Fripp (who credits Brian Eno for introducing him to the original technique) started creating these pieces, which he called Frippertronics, using a pair of reel-to-reel tape machines as the delay line. Later, after a technology upgrade, he started using the name Soundscapes. The earlier Frippertronics/Soundscapes works were named arbitrarily using years, starting with 1983.

In the same vein, I decided to use, as a set of arbitrary names, the names of the 50 U.S. states. Towards that end, I call my efforts Statescapes. State names are assigned to the pieces randomly -- usually I decide on the name before I start a piece. It gets stuck onto whatever comes out, and the result is what it is.

This was the first of my series of experiments with improvising against very-long-period delays. This first improvisation was done entirely with the Juno-106 and the Boss DD-20 delay, set up for a delay time of 20.0 seconds. About 25 different patches were used on the 106. The version here consists of the complete third take, with no edits. (I broke off the first take because the recording levels got out of control; I completed the second take but it wasn't very good and I decided not to keep it. This one came out much better.) I started out with an idea of how I wanted to begin, and with a few notions of things that I wanted to do at some point during the song, but other than that, it was all improvised.

Two more of my long-period-delay improvisations. The setup for these was much different than for "West Virginia". Both pieces used the same basic setup, with a few tweaks, which is why I gave them complimentary names. (Otherwise, the names have no specific meaning, as with all of the Statescapes.) If you've listened to West Virginia, you may be in for a surprise...

Both tracks are based on a drone patch I created on the Oberheim Matrix-1000. (The Oberheim Matrix series are among the few polyphonic synths I know of that allow drones − that is, patches that sound indefinitely without any keys held − to be created. One way to do it, which is the method used here, is to set up Envelope 2 to be retriggered by an LFO. Envelope 2 is hardwired to the output VCA, so retriggering it can produce either repeating or continuously sounding patterns of notes.) The patch is something I stumbled onto while testing the patch-randomization features in the original version of M1000X. It is set up to feed continuously into the GigaDelay, so the repeats being heard are a combination of the repeats from the delay (which gradually fade out but otherwise do not change) and the repeats from the patch itself, which do evolve and change as the various control signals change, and as I poke at keys and manipulate controllers. I also tweak the patch itself on the fly with M1000X while playing. (Lots of running back and forth between the keyboard and the computer!) The signal is mono and gets fed into one channel of the GigaDelay.

Because the Matrix patch is such an aggressive sound, I decided to offset it with something relatively conventional, that being a factory electric-piano patch from the JD800. This goes through the other channel of the GigaDelay, so it gets the same delay time as the Oberheim. To differentiate it (read: "mess it up") a bit, I use the Ibanez HD1000 pitch shifter on it. On North Dakota (which was the first of the two works to be recorded), I placed the GigaDelay channel in the HD1000's feedback loop. That produced an interesting series of echoes with rising and falling pitch, but it also produced an awful lot of digital noise is the GigaDelay recycled the HD1000's inherent 8-bit quantization noise. The recycling noise was kind of interesting, but it dominated the track to the point where I decided to change that configuration for South Dakota. On that track, the JD800 goes through the pitch shifter first, and then the output of that goes to the delay, so the echoes are not recycled through the pitch shifter.

On North Dakota, both of the echo channels went directly to the mixer. For South Dakota, I decided to do something to give the Oberheim more of a stereo presence. I fed the output of the GigaDelay channel which carried the Oberheim echoes into the EML 101's filter, and took two outputs from the filter into the mixer − bandpass into the left channel, and highpass into the right channel, with the filter resonance turned up moderately high. I drove the filter cutoff with a complex chain of LFO signals using both the EML's oscillator 1, and an external signal from the modular, out of the Q161 oscillator waveform mixer. (You can hear some of the oscillator's action as a slight thump in the signal at the end of South Dakota.)

On both tracks, the left and right channels were taken through the Lexicon which was set up for a complex ping-pong delay with multiple asymmetrical taps, to further add to the stereo effect. I used more of the taps on South Dakota, and fewer on North Dakota, to keep the ping-pong from dominating the mix on the latter.

For this Statescape, I went in a different direction. Rather than being improvised on the fly with a digital delay, I did this entire piece (except for a few samples) in Csound.

I started by constructing the delay line I would use. To take advantage of Csound's power, instead of a single delay, I constructed an interlocked set of two delays. The first is a triple-tapped delay with taps at 6, 8.1, and 13 seconds. The first tap is panned left, the second one is panned right, and the third is panned slightly right. A mix of the three taps is fed to the second delay, which is a mono 30-second delay. The 30-second delay's output is panned center, and it in turn is fed back to the multi-tap delay. Also used is a Gardner reverb, which is applied to all of the outputs and also feeds a bit of signal directly into both of the delay lines, resulting in a reverb that repeats independently of the original signal's repeats.

With all that, I then proceeded to use the constructed delay as a basis for feeding some of my Csound experiments into. Much of the sound came from my prototype VCDO code, as described in the "experiments" section below. Phase modulation, symmetry modulation, hard sync, and phase-range sync were all used extensively. (To do it all, I constructed a set of auxiliary instruments in Csound whose purpose was to drive global variables that served as modulation inputs to the VCDO code itself.) Pitch shifting, with the harmon opcode, was used in one place near the start of the piece to create a sort of cloud generator effect. Another bit of code that I used, which is destined to become hardware eventually, is a bit that I refer to as a Tangential Morphing Oscillator, or TMO. The TMO approximates sets of sine waves using line segments of varying lengths.

I also experimented considerably with some Csound built-in operators that I had not used previously. I played with the fmbell instruction, feeding it various non-sine-shaped waveforms, and among other things I discovered that it can do a passable imitation of tympani when fed triangle waves. The plucked-string (Karplus-Strong method) and dripwater (elastic collision simulation) opcodes also got a workout. (One of the things I discovered with dripwater is that the PHiSEM-based opcodes are unstable in output amplitude and rather difficult to control. The output amplitude seems to depend considerably on the initial state of internal quasi-random variables within the operator's code. Calls with identical parameters can produce wildly different results, or sometimes no sound at all, depending on what other calls have preceded them.) In addition, I did three short runs of granular synthesis using the grain opcode. Two of the samples that were granulated came from a patch on the EML; I set up the patch and played short runs of notes to create the 5-10 second samples. The third one, which can be heard near the end of the piece, is the Macintosh's speech synth saying "It's two o'clock". Hey, it was late. These three sounds were the only sounds in the piece that were not produced totally with Csound alone.

Obviously, with all of this code hacking going on, the standard process of real-timing chords and sounds into a delay line went out the window. To try to preserve the integrity of the process, I had started with the principle that I would build the whole score without any previewing, and live with the result. However, in doing a short "test run", I found out why that wouldn't work -- overflows. Without being able to hear the result as I went, I had no idea at any point in time what the output level of the delay lines already was or how much I was increasing the overall level with anything I added, it was impossible to build the score without getting substantial amounts of clipping in some places when the score was rendered. So it was necessary to build up the score a little bit at a time, render, check for overflows, and tweak levels before moving on to the next bit. And the process wasn't quite that linear; there were places where I went back in after listening and added some more detail bits to break up some long boring stretches. However, I did try to remain true to the process by not moving, deleting, or altering the non-level-related parameters of any event once it was inserted into the score. I made myself live with some rather startling results.

Concerning that: Fripp, in the liner notes to his Radiophonics Soundscape album, talks about how some of the Soundscapes he did for that album took on a life of their own, and went off in directions that the artist didn't intend, with rather frightening results in places. Before I did this piece, I wasn't sure what he was talking about. Now I know. Quite frankly, there are some bits that I would never have thought to do, or would have resisted using had I thought of them. Maryland has a lot more dynamics in places than any other piece of this type that I've ever heard, either in my own efforts or in anyone else's. (You might want to watch your levels the first time you listen to it.) There is at least one place that I can think of where, if I didn't know what was coming, might make me jump up from my chair and run out of the room! It's one of the more unique, and somewhat disturbing, things I've ever done.

For this Statescape, I went back to the DD-20 as the delay line, with a length of 8.6 seconds. I had decided that I wanted to try doing something with more percussive, less sustaines sounds. I added one other element: a ping-pong tremolo effect, created by the MPX 500, and preceding the delay line. This was mixed back in with the dry signal, which was stereo but focused mostly to center. I chose to use a combination of patches with percussive attacks (except for at the very end), produced by the JD-990. I created three patches on the JD-990 specfically for this piece. The bass sounds are from the JD-800. The method of controlling these was rather backwards: I used the 800's keyboard (with MIDI Local Control off) to play the 990, and a set of bass pedals to play the bass patch on the 800. Most of the patches were set up to pan bass notes slightly left and treble notes slightly right. In a test run-through, I had added some drums, but decided not to do that when I did the real take.

The tremelo effect chopped up the notes going into the delay to give the output a stereo spread. Actually, it turned out being a bit more of a spread than I intended: in some places, it actually sounds like a stereo expander is being used. But there isn't. The tremolo chops up runs of notes, placing some of them hard let and others hard right. Through headphones, the effect is somewhat disorienting. As I played, I added some sustained notes which had the effect of filling the hole in the middle of the stereo field. This was unanticipated and quite interesting, so I played with it quite a bit in the center section of the piece. Towards the end, I started using pitch bend downwards on everything, which when chopped up by the trem and delay produced the ending effects.

I was quite pleased with the result, although it didn't quite turn out like I thought it would. But these Statescapes seldom do. That's part of the intrigue. At one point, I selected the wrong patch on the JD-990 and wound up with a piano sound. I didn't realize that I had the wrong patch until after I had played several chords into the delay. Instead of aborting, I decided to work with it and kept going. It wound up being one of the best bits. You never know about these things.

This Statescape was a first for me: I video'ed the performance, making my first "music video" which is available on Youtube here. The goal here was a performance that would be visually interesting, as well as fitting within Youtube's 10-minute length limit after a brief introduction was included. (The MP3 file here does not include the introduction.) I decided to use the JD800 and do a lot of tweaking on a few basic patches as I played, which would allow me to demonstrate the tweakability of the JD800 as well as create neat sounds. As it turned out, I used only two patches -- but with a ton of tweaking. The bass pedals were used again here, this time routed to the Matrix-1000 playing a bass patch. Again, the MPX500 tremolo effect was used to provide a stereo image. Since I was trying to keep the piece short, I started with a shorter 3.6 second delay on the DD-20. However, I altered the delay time quite a bit in several places towards the end, and if I recall I ended up with something on the order of 5.2 seconds after all the thrashing.

The audio file here is of much higher quality than the audio soundtrack on the video. It's also somewhat longer -- I had to trim the last minute or so on the video to fit the length limit.

Idaho began with a concept that I've had in my mind for a while: to build some patches with "reverse" envelopes, play something, record it, then play it back backwards. By a "reverse" envelope, I mean an envelope with a very slow attack and an abrupt release; when recorded and reversed, such a patch should exhibit a piano-like envelope.

I built a set of five patches, using four different synths: two on the V-Synth, and one each on the JD990, the Morpheus, and the Fizmo. On the V-Synth and the Morpheus, I was able to set up patches with self-terminating notes; that is, the note cuts off at a given length regardless of how long the keys are held. The Fizmo and JD990 patches released in the conventional manner, with the physical release of the keys. I then played some parts, trying to keep in mind (not very successfully) how the runs and melodies were going to sound when reversed; it was harder than I thought it would be! The other problem I ran into was that I couldn't play the whole thing through in one pass, due to the limitations of my MIDI setup. I had to record the parts for each synth separately. This involved recording a few phrases, stopping, resetting the song position pointer, switching to the next instrument, recording a few more phrases, etc. However, I did make myself live with whatever came out. All of the tracks were recorded as MIDI and there was no editing.

After finishing the tracks, I played it all back and mixed the result to an audio track, which was then reversed. After that, the track was played back through the DD-20 to add the delay, making the completed "Idaho" track. (This was the other difficulty in playing the individual tracks: not being able to interact with the delay, since it wasn't present at that point.) However, I had an additional idea for a variation on the theme. I took the same "dry" audio track, ran it through the DD-20 in the forwards direction, and then reversed it, creating a reverse echo. This is quite a different effect -- the track builds up very slowly, and ends abruptly. It's the first time I've tried this. The result is the second linked song above, "Ohadi" (which the quick-witted have already noted is "Idaho" backwards). I have also thought about preparing the "Ipayo" ("Idaho" upside down) version with delay added to the non-reversed dry track, and the Oyapi version with reverse echo on the non-reversed track. But I personally find the non-reversed track rather annoying to listen to; some of the patches have a irritating accordian-like quality when not reversed.

The results are pretty interesting, especially since I couldn't avoid playing with the Time Trip pad on the V-Synth in some places, which considerably preturbed the basic patches being played there. I also tweaked the EQ on th JD990 track quite a bit as it was being mixed. There are a couple of places in the Ohadi track where it sounds like somebody is speaking -- I can assure you that there are no vocals! The two tracks here are the result of the complete third attempt. The first attempt was a short test that I did to see what the patches would sound like when reversed. I might edit it to take out some bits that didn't sound good and release that as a separate track later. The second take just didn't work out. Although I still have the files, I probably won't do anything else with them.

Just before Christmas 2009, I was reviewing all of the Statescapes, and I realized how atonal most of them have been up to this point. All of the Statescapes are of course process music, in that they are all based around a certain method of creating sound, as opposed to a conventional composition. However, it occurred to me that I could stand to do a Statescape that would be a little more music and a little less process.

However, I also wanted to try an idea that I've had in my head for a long time: using Csound to create a delay line for a real-time signal. Once I figured out how to access the audio interface in a Csound instrument, I wrote code for a stereo delay line with four taps. On the left channel, the taps are 12 seconds apart; on the right, 18 seconds apart. The signal swaps channels after the second and third stages, and the outputs of the fourth stage are fed back to the first stage, at a reduced level, to create the repeats. The second stage right channel output, and the third stage left channel output, are routed to a pitch shifter (the Lexicon MPX 500 on a pitch shift program) which was set to lower the pitch of its inputs one whole step. The pitch shifter output is mixed with the direct and delayed signals, but is not fed back into the delay line. (I did do that by accident at one point, and the effect was interesting, but it wasn't what I wanted for this piece. I'll keep that trick in my pocket for later.)

The key to all of this is that the delay line times, and the pitch shifter output, were chosen to work with the sound pallette I had in mind -- a selection of exclusively pad and string patches. Towards this end, I designed several new pad patches for the V-Synth, including one that used a sample of two Mellotron sounds from the M-Tron software. I combined these with some factory patches to build a bank of eight on the V-Synth, which became the primary sound source. I also used some existing pad patches from the JD-800. And for the first time, the Hammond A100 organ got in on the act in a Statescape -- I had four sets of drawbar settings. The Hammond was miked up with a Rode NT4 stereo mic pointed at the speaker grille under the manuals, and fed though the Midiverb on a flanger setting. I mostly did swells with it; since the mic was in the way of the swell pedal, I reached over and used the faders on the mixer to do that, playing chords with one hand. The Hammond's scanner was set on C-1 and the reverb was all the way up.

All stereo sound sources were used. The routing in and out of the MOTU 828 audio interface got complicated, and I wound up using its monitor feature to mix the pitch shifter output with the other signals. It took some doing to get the delay line tuned to reasonable values. The first time I tried letting it go until it faded out, I played a single note and it rattled around inside the delay line for 11 minutes! That obviously was going to turn into mush, so I worked on it until each note played was fading out in 4-5 trips through. That produced a (mostly) very pleasing and musical sound with the patches that I used. There were a few overflows in the delay line that occurred during the playing, but they weren't too bad so I left them alone. As usual, this piece consists entirely of one continuous take, with no overdubs.

If you liked West Virginia, you should like this one.

This is my first track done with the brand-spanking-new Solaris from John Bowen Synth Design. This is the first time I've done an entire Statescape with nothing but the synth itself. No external delay line was used; the delays were done using the delay line built into the Solaris' effects channel. I set it up in the cross-feedback stereo mode, with a delay time of 13.5 seconds on the left channel and 10.5 on the right.

All of the noise here comes from a single patch, which I set up to have four parts, or tones. The Solaris has four panel buttons which allow each of the four part VCAs to be turned on and off while playing, somewhat in the manner of the old Roland JD-800. Using these, I was able to, in effect, switch patches while playing, without disturbing the effects settings which are part of the patch. There was also some parameter tweaking that went on during the proceedings; the Solaris is fantastic at real-time tweaking. The edit screens and rotary encoders let you select a parameter from a recalled patch and tweak starting with the current value, rather than having the parameter jump to whatever value the knob is set at.

There are four basic tones to the patch. The first, and the first sound you hear in the track, is an organ-like patch. There is an FM tone, which uses the ribbon controller to vary both the modulation index and a comb filter. There is a vector tone which incorproates the FM tone and a rotor as two of its sources. The vector is controlled by the joystick. And then there is a second rotor tone, which got a lot of tweaking in the two or three places where it appears. Ribbon, joystick, pitch and mod wheels all get a workout. And as stated above, the synth's outputs went straight to disk with no further processing or effects.

The state name chosen for this Statescape is a tribute to John Bowen, who lives in Washington state.

Title	Length	File Size	Format	Bit Rate	Download Time
Wisconsin	11:42	16.9 MB	MP3 stereo	192k VAR	12:30

I have been working for a while on a different idea for delay lines: having the sound that is circulating in the delay line to interact with incoming sounds in some manner other than just being mixed together.  So for this one, I tried something different: I coded up, in Csound, a delay line that amplitude-modulates the incoming signal with the delayed signal.  The results were, as they say, different.  I'm putting a more detailed post about this one on Sequence 15. 

Sound samples, experiments, and song fragments

I have in the works a plan to someday build a voltage-controlled digital oscillator (VCDO) for my modular. I recently completed writing up a prototype of its software in Csound. The prototype code produces sine, triangle, ramp, and pulse waveforms; all except the sine are computed on the fly (the sine is from a lookup table). One of the considerations for building a VCDO is: what is a digital oscillator in a modular good for? What can it do that an analog VCO can't do? Here's one: In a digital oscillator, it's quite easy to mess with the time base. (The standard sawtooth-core VCO circuit relies on the charging rate of a capacitor as its time base. The consistency of this cap charging is crucial to the VCO's frequency stability. It's a precarious enough sitaution as it is, without trying to do tricks with it!) Implementing phase shifting and phase modulation in a VCDO is a snap; just add or subtract some value to/from the current phase index. Similarly, it's fairly easy to apply scaling curves to the time base that depend on the current phase index value, so that time can be "sped up" or "slowed down" over the duration of each cycle. This is one way of implementing pulse width modulation; start with a square wave, and accelerate or decelerate time in the initial part of each cycle to increase or decrease the pulse width. However, there's nothing to stop one from applying this same phase distortion to other waveforms too, producing waveforms with harmonic content that differs greatly from anything that generally comes out of an analog VCO.

This sound sample is a brief melody produced by my VCDO code prototype, as rendered by Csound. It illustrates the various tricks that the code can do. All four waveforms are available in any proportion and can be mixed on a per-note basis. Symmetry modulation and phase modulation are applied at various points. (I'm still working on implementing oscillator sync, which should be a fairly simple matter.) All of the timbres heard here are straight out of the VCDO code; no filtering is used.

One other technique illustrated in this sample, which has nothing to do with the VCDO code as such, is a reverb algorithm known as a Gardner reverb. (The link is to Bill Gardner's MIT Media Lab project page. Scroll about halfway down the page to the heading "Reverb algorithms" and start reading there.) The Gardner reverb uses all-pass filters with feedback and feedforward to generate reverberation. The algorithm I used is based on the small-room reverb presented on p. 487 of The Csound Book. I originally used this code on the Virtual Analog Sawtooth Oscillator experiment (below), with very satisfactory results. However, for some reason, when I used the same code for this VCDO experiment, it came out sounding like a tin can, and I had some problems with runaway feedback. I had to tweak the parameters empirically to get a satisfactory result.

This was an experiment in writing code for a "virtual analog" oscillator; that is, a piece of code that mimics the the physical behavior of an analog circuit, with all of its quirks. Inspired by a discussion that took place on the Synth-DIY mailing list in the spring of 2006, it occurred to me that a source of frequency instability in a sawtooth-core VCO circuit might be the reset trigger. A sawtooth-core VCO works by charging a capacitor at a rate that is proportional to the desired output frequency. When the capacitor voltage reaches a fixed threshold, a comparator, which continuously compares the capacitor voltage to a voltage standard generated by another part of the circuit, triggers a mechanism (such as a bipolar transistor) to discharage the capacitor. The cycle then starts over.

Part of the Synth-DIY discussion focused on whether variations in the trigger circuit -- either drift in the voltage standard, or inaccuracy in the behavior of the comparator -- might contribute to short-term and long-term frequency drift in a VCO. To find out, I wrote some Csound code to mimic the sawtooth core. The code adds to an accumulator variable an amount proportional to the output frequency in each sample time. When the sum exceeds a cutoff value, the variable is re-zeroed. This accumulator variable is the output of the code, so it rises at a fixed rate (assuming a constant frequency) until it reaches a cutoff value, then it drops to its minimum value and starts over -- the definition of a sawtooth wave. I introduced into the code a random-walk drift into the cutoff value. The width of the random walk is specified on a per-note basis.

In April 2006, I produced a pair of brief samples of the output of this code, one with the random walk disabled, and another with it enabled, and offered them for listening by the Synth-DIY community. The results were inconclusive. No one really felt that it captured the full character of an analog oscillator (I didn't expect it to). Some listeners did feel that the drift was analog-like. Others, however, didn't feel that the frequency anomalies introduced resembled those of an analog oscillator. I think this may have had to do with the uniform-distribution algorithm I used to generate the random walk (a real analog circuit probably does not behave this way, at least not over a long period of time), and also the fact that Csound introduced some quantization to the process that I still haven't managed to track down. I plan on doing some more work on this. In the meantime, here is a short sample of the code's output, enhanced with the Gardner reverb as described above.

I am always on the lookout for new and different ways of modulating basic waveforms, so as to produce new and unusual timbres. One thing that has been useful for me is to look at the various means used to modulate radio carriers in spacecraft telemetry systems. A method often used to transmit digital data on a carrier is called phase shift keying. It's sort of a quantized form of phase modulation. As an example, the most basic form of this is known as biphase keying; one way of implementing this would be to invert the carrier (which constitutes a phase shift of 180 degrees) when a 1 bit is to be transmitted, and leave the carrier unchanged when a 0 bit is to be transmitted. This is done on a per-cycle basis. A more complex form capable of transmitted two bits of information per cycle is quadrature phase shift keying, which uses phase shifts of 0, 90, 180, and 270 degrees. (The Space Shuttle uses this method for most of its higher-rate downlinked data.)

In a musical application, we are not limited to using powers of 2 for our phase shift values. So far, I have actually obtained the most musically interesting results using sets of 10 to 16 discrete phase shift values. This sound sample uses sets containing from 4 to 16 phase shift values for modulating the various notes. In all cases, the original sound source is a simple sine wave. No other processing or effects are present.

These bass drones were both created using the AM capability of the H-P 3312A function generator. The Juno-106 was routed to the modulation input of the 3312A, and a bass patch with subosc and chorus was selected. The function generator was set up to output a triangle wave of about 120 Hz, and then tuned for minimum beating with the input from the 106. A small amount of reverb was added using the Midiverb II. All effects were created by striking the G# note in different octaves and sweeping the filter on the 106.