You may have noticed that it is a bit of a pain to have to evaluate each note each time you want to play it. There is an easy way around this that we have used in the drum machine tutorial that can be applied to pretty much anything that needs to repeat in Impromptu.

First up, we disconnect everything.

; Make sure that everything is disconnected
(au:clear-graph)

Then we define the library and connect it.

(define dls (au:make-node "aumu" "dls " "appl"))
(au:connect-node dls 0 *au:output-node* 0)
(au:update-graph)

You should recognise most of this so far from the piano tutorial. We can play a drum the same way. Have a look at the General MIDI Level 1 Sound Set for more information on what numbers equate to what drums.

; Playing a drum beat the same way as we played
; notes in the piano tutorial.
(play-note (now) dls 36 80 20000 9)

Now to simplify the playing of each note or beat, we want to create a function. In this case we will be calling it drum-machine.

; Define the drum-machine function.
(define drum-machine

; Tell Impromptu to move forward in steps.
(lambda (time step)
(print step)
(case step

; For steps 0 and 8 do this:
((0 8 )
(play-note (now) dls 42 80 20000 9)
(play-note (now) dls 36 80 20000 9))

; For steps 4 and 12 do this:
((4 12)
(play-note (now) dls 42 80 20000 9)
(play-note (now) dls 38 80 20000 9))

; For step 15 do this:
((15)
(play-note (now) dls 46 80 20000 9))

; For any other steps do this:
(else (play-note (now) dls 44 80 20000 9)))

That’s fairly straight forward right? It uses exactly the same play-note commands and parameters that we have used before, however it puts them within a step function that tells impromptu to play through the notes in steps and to play certain notes at certain steps.

This doesn’t repeat though. In order to make it repeat, we tell Impromptu to run a callback to the drum-machine function. This sends it back to drum-machine. and so it goes through the steps again and will continue to do so until something gets changed that doesn’t work, such as a close bracket immediately after (define drum-machine.

(callback (+ time 10000) drum-machine (+ time 9000) (modulo (+ step 1) 16))))

Now, of course just having this setup doesn’t mean it will run when you evaluate it. You have to create a function call. This is specified below along with when to run it (now).

(drum-machine (now) 0)

Once you have evaluated all of the components of the program you should be able to evaluate the function call and it will run the drum-machine function, a constantly looping drum machine that you can change on the fly.

Thats right, if you want to change one of the drum sounds, when it’s playing, or anything like that, all you have to do is edit it and then re-evaluate that single line and it will be played from then on as part of the constant loop. You can also add more steps, remove steps, change what is played for certain steps, re-evaluate it and it becomes part of the loop. Easy as that.

We were looking at creating audio based on the Apple Sound Bank Synthesizer using the MIDI specifications.

As an introduction to this topic we started off simply by writing the code to play a single note on a piano.

To start with, we clear everything from the au graph.

; Make sure that everything is disconnected
(au:clear-graph)

Next we define the piano and create a basic au graph that connects the piano library to the output.

; setup simple au graph
; piano -> output
(define piano (au:make-node "aumu" "dls " "appl"))
(au:connect-node piano 0 *au:output-node* 0)
(au:update-graph)

Now we tell it to play a note. It is formatted as follows:

(play-note time instrument pitch volume duration)

Time is of course, when the note is to be played and duration is how long for. In the example below, we have defined that the note will be played immediately, it will be from the piano library we defined earlier, the pitch is set at 60 with a volume of 80, and it is held for 1 second. To add more notes, simply copy the line and paste it before or after and change the parameters to meet your needs.

; play note on piano
(play-note (now) piano 60 80 (* 1.0 *second*))

The following are not required. The first line just prints out information about the device in the log view.

The second line opens the Apple Sound Bank Synthesizer properties and parameters which allow you to adjust settings such as the tuning, volume, reverb volume, audio streaming, render quality, and CPU load restriction.

(au:print-audiounits "aumu")
(au:open-view piano)

Now this is all well and good, but how do you make it play?

The easiest way is to press Option > E on your keyboard to tell it to evaluate. Alternatively you can press the evaluate button in the top right of the Impromptu editor. Now, this won’t evaluate the entire program, you will have to do each line individually starting from the beginning. So in some cases, it may be best to evaluate as you are going.

Click near the start of a line and ensure that the entire line and anything on seperate lines that are within the series of commands are highlighted and then hit evaluate.

Work your way through and once you reach play-note, it should play the note with the parameters that you specified.

If you try to evaluate the note first, it won’t play. This is because the MIDI library hasn’t been connected yet.

If you have put in multiple notes than you will have noticed that you have to evaluate each note whenever you want to hear it. This is a pain and it will be addressed in my next post where we will be making a drum machine in Impromptu.

It is designed for OS X, and this is probably part of the reason I have not come across it before since it was only November that I seriously started using a Mac.

Impromptu uses the Scheme programming language and is particularly suited to live programming, however in using it myself, it is obvious that the features built into it to assist live programming make regular programming much easier as well since changes can be made on the fly.

Impromptu is developed by Andrew Sorenson from QUT. As I am studying computational arts at QUT, it would be almost impossible to not come across Impromptu sooner or later.

My tutor and lecturer have both commented that as far as generating computational audio, Impromptu is one of the best development environments as it is oriented strongly around time and timing so that things can be scheduled accurately. Apparently other environments over periods of time can start to get slightly out of time, where Impromptu doesn’t.

It also supports a whole heap of graphic generating options, such as OpenGL rendering and vector drawing, along with many more, which is quite nice.

I haven’t used it in depth, but my experience with it thus far is that it is very straight forward and simple to use. I have never written anything in Scheme before, but it seems easy to learn and the Impromptu environment helps make it even easier.

The audio that is used is MIDI generated and follows the standard outlined on the MIDI Manufacturers Association website.

Thus far I have seen examples of and written my own drum kit, bass line, and I have been experimenting with an entire musical piece as well, slowly. I’ll be going through these things a bit later on.