We’ve made some big steps lately so I figured it was time for a short update. Fabian’s great work on the native bindings for the SuperCollider synthesis server now allow us to boot the audio server in the same process as the JVM. This means we can share buffers of audio data with the DSP engine with minimal communications overhead, allowing for real-time visualization and soon manipulation of audio waveform data.

The new (oscillo-)scope renders the contents of a buffer. It can animate in real-time with an adjustable fps, but their is no zooming or waveform manipulation yet. It’s already usable for checking out waveforms and learning, but hopefully there are still some good opportunities for optimizing this widget to get a bit cleaner, real-time waveform without jitter. (I haven’t tried out either the concurrent garbage collector or the real-time JVM, both of which could be interesting.)

  ; View a full sample waveform
  (def s (load-sample "/home/rosejn/studio/samples/kit/boom.wav"))
  (scope-buf s)

  ; view a live waveform
  (def b (buffer 2048))
  (defsynth foo [out-bus 20] (out out-bus (sin-osc 400)))
  (foo)           ; output a sine wave onto bus 20
  (bus->buf 20 b) ; record signal from bus 20 into buffer b, looping
  (scope-buf b)   
  (scope-on)      ; enjoy
  ;...
  (scope-off)     ; stop live updates

Shown in the oscilloscope is a kick drum sample.

Below the oscilloscope is the new curve editor. This is the result of a late night hacking session last night, so there is plenty more work to do, but this will allow us to visualize and manipulate the control points for envelope and automation curves.

The color chooser in the toolbar on the side emits a :color-changed event when the color is changed. For most stuff you can probably just use the live-color function though. Here’s how you can change the color of the curve editor interactively:

  (live-color #(curve-color %))
  ;... change color ...
  (stop-color)                       ; remove the handler

I’ve been thinking about how to generate a little theme configuration panel that lets you see all of the colors used by the application, adjust them interactively, and then save out into a named theme setting. This will be one of the building blocks.

Our goal for this first draft of an actual Overtone application is to create a tool that is good for designing and playing a single instrument. This includes a basic live-coding editor, a repl, the oscilloscope, the curve editor, and a few generic controls to trigger synths and control parameters. Oh, and some basic midi hooks to make it easy to use a keyboard or a monome to trigger synths. We are probably a month or two away from the first alpha release.

The audio synthesis API that communicates with SuperCollider is operational. You can define a synthesizer, load it and then trigger it and send it control messages to adjust parameters. Here’s a short example of creating and playing a simple synth on the repl.

(use 'overtone.live)

; import the UGen function library
; we do it this way because we need to override a bunch of built-in clojure
; functions, including +, -, *, / and other common functions.  Doing it like
; this saves you from having to exclude all this in your namespace definition.
(refer-ugens)

; boot the synth server
(boot)

; here is a random, echoing, ping synth
(defsynth chop-saw [freq 440 depth 5]                                                                                     
  (comb-n (* (env-gen (perc 0.1 0.4) (lf-pulse:kr 2)) 
             (rlpf (saw (+ freq (* depth 
                                (lf-saw:kr (lf-pulse:kr 0.1 0.2))))) 
                   freq 0.6))))

; play it
(chop-saw)

; kill the synth instance based on the last returned node id
(kill *1) 

; play it with different settings
(chop-saw 440 20)

; and control them on the fly
(chop-saw :ctl :freq 880 :depth 10)

; make some more
(chop-saw :freq 440)
(chop-saw :freq 220)
(chop-saw :freq 110)

; clear all running synths
(reset)

; quit the synth server
(quit)

A graph based editor (connecting nodes with edges) is coming to life now. This will allow you to define synthesizers and control patches in a basic graphical programming environment. Here’s a screenshot showing some of the widgets implemented in the first prototype (click to zoom):

Overtone can be used as a library from Clojure code or on the repl, but there is also the beginnings of a standalone application. It currently boots the server and it has a repl that can evaluate code, but it will soon get a text editor and the flow editor.

Overtone lives!

(use 'overtone.sc)

(boot)
(hit (now) "kick")
(quit)