A Brief History

Beginnings of Computer Music

First experiments on digital sound creation took place 1951 in Australia, on the CSIRAC computer system.

Besides from these experiments, digital sound synthesis dates back to the first experiments of Max Mathews at Bell Labs in the mid 1950s. Mathews created the MUSIC I programming language for generating musical sounds through synthesis of a single triangular waveform on an IBM 704. The Silver Scale, realized by psychologist Newman Guttman in 1957, is one of the first ever digitally synthesized piece of music (Roads, 1980).


MUSIC and its versions (I, II, III, ...) are direct or indirect ancestors to most recent languages for sound processing. Mathews defined the building blocks for digital sound synthesis and processing in these frameworks (Mathews, 1969, p. 48). This concept of unit generators is still used today. Although the first experiments sound amusing from today's perspective, he already anticipated the potential of the computer as a musical instrument:

“There are no theoretical limitations to the performance of the computer as a source of musical sounds, in contrast to the performance of ordinary instruments.” (Mathews, 1963)

Mathews created the first digital musical pieces himself, but in order to fully explore the musical potential, he was joined by composers, artists and other researchers, such as Newman Guttman, James Tenney and Jean Claude Risset. Risset contributed to the development of electronic music by exploring the possibilities of spectral analysis-resynthesis (1:20) and psychoacoustic phenomena like the Shepard tone (4:43):


Later, the Bell Labs were visited by many renowned composers of various styles genres, including John Cage, Edgard Varèse and Laurie Spiegel (Park, 2009). The work at Bell Labs will be in focus again in the section on additive synthesis.


A Pedigree

The synthesis experiments at Bell Labs are the origin of most music programming languages and methods for digital sound synthesis. On different branches, techniques developed from that seed (Bilbao, 2009):

/images/basics/bilbao_history.png

Chowning & CCRMA

The foundation for many further developments was laid when John Chowning brought the software MUSIC VI to Stanford from a visit at Bell Labs in the 1060s. After migrating it to a PDP-6 computer, Chowning worked on his groundbreaking digital compositions, such as Turenas (1972), using the frequency modulation synthesis (FM) and spatial techniques. Although in particular known for discovering the FM synthesis, these works are far more than mere studies of technical means:


Puckette & IRCAM

Most of the active music programming environments, such as Puredata, Max/MSP, SuperCollider or CSound, are descendants of the MUSIC languages. Graphical programming languages like Max/MSP and Puredata were actually born as patching and mapping environments. Their common ancestor, the Patcher (Puckette, 1986; Puckette, 1988), developed by Miller Puckette at IRCAM in the 1980s, was a graphical environment for connecting MAX real-time processes and for controlling MIDI instruments.

The new means of programming and the increase in computational power allowed musique mixte with digital signal processing means. Pluton (1988-89) by Philippe Manoury is one of the first pieces to use MAX for processing piano sounds in real time (6:00-8:30):



References

  • John Chowning. Turenas: the realization of a dream. Proc. of the 17es Journées d’Informatique Musicale, Saint-Etienne, France, 2011.
    [BibTeX▼]
  • Bilbao, Stefan. Numerical Sound Synthesis. Wiley Online Library, 2009. ISBN 9780470749012. doi:10.1002/9780470749012.
    [BibTeX▼]
  • Ananya Misra and Perry R Cook. Toward Synthesized Environments: A Survey of Analysis and Synthesis Methods for Sound Designers and Composers. In Proceedings of the International Computer Music Conference (ICMC 2009). 2009.
    [BibTeX▼]
  • Tae Hong Park. An interview with max mathews. Computer Music Journal, 33(3):9–22, 2009.
    [BibTeX▼]
  • Julius O. Smith. Viewpoints on the History of Digital Synthesis. In Proceedings of the International Computer Music Conference, 1–10. 1991.
    [BibTeX▼]
  • Miller S. Puckette. The patcher. In Proceedings of the International Computer Music Conference (ICMC). 1988.
    [BibTeX▼]
  • Emmanuel Favreau, Michel Fingerhut, Olivier Koechlin, Patrick Potacsek, Miller S. Puckette, and Robert Rowe. Software developments for the 4x real-time system. In Proceedings of the International Computer Music Conference (ICMC). 1986.
    [BibTeX▼]
  • Curtis Roads and Max Mathews. Interview with max mathews. Computer Music Journal, 4(4):15–22, 1980.
    [BibTeX▼]
  • Max V. Mathews. The Technology of Computer Music. MIT Press, 1969.
    [BibTeX▼]
  • Max V Mathews. The Digital Computer as a Musical Instrument. Science, 142(3592):553–557, 1963.
    [BibTeX▼]
  • SynthDefs

    Sending a SynthDef to a Server

    SynthDefs are templates for Synths, which are sent to a server:

    // define a SynthDef and send it to the server
    (
    
    SynthDef(\sine_example,
    {
       // define arguments of the SynthDef
       |f = 100, a = 1|
    
       // calculate a sine wave with frequency and amplitude
       var x = a * SinOsc.ar(f);
    
       // send the signal to the output bus '0'
       Out.ar(0, x);
    
    }).send(s);
    
    )
    

    Create a Synth from a SynthDef

    Once a SynthDef has been sent to the server, instances can be created:

    // create a synth from the SynthDef
    ~my_synth = Synth(\sine_example, [\f, 1000, \a, 1]);
    
    // create another synth from the SynthDef
    ~another_synth = Synth(\sine_example, [\f, 1100, \a, 1]);
    

    Changing Synth Parameters

    All parameters defined in the SynthDef of running synths can be changed, using the associated variable on the client side:

    // set a parameter
    ~my_synth.set(\f,900);
    

    Removing Synths

    Running synths with a client-side variable can be removed from the server:

    // free the nodes
    ~my_synth.free();
    ~another_synth.free();
    

    Control Rate and Audio Rate

    Like many other audio programming environments, PD makes a difference between control signals and audio signals. They run at different rates and can not be combined, unless converted. Audio operations require the DSP to be activated, whereas control rate signal work at any time. Objects define whether an outlet gets or outputs control or audio rate signals. Objects with audio inputs or outputs are usually named with a ~. Control rate connections are thinner than audio rate signals. The example rates.pd simply shows an audio and a control rate connection:

    /images/basics/pd-rates.png

    Audio to Control

    Converting audio signals to control rate signals can be achieved with the snapshot~ object, as done in the example audio-to-control.pd. A possible application is an envelope follower. This object needs to be triggered to grab a snapshot, which is done with a metro object at 100 Hz in this example. The output is a level indicator for the LFO at 0.1 Hz:

    /images/basics/pd-audio-to-control.png

    Control to Audio

    Usually, control signals can be connected to audio inlets. The conversion shown in the example audio-to-control.pd is thus less frequent. However, in some cases it might be necessary to convert control signals to audio rate. This is done with the sig~ object:

    /images/basics/pd-control-to-audio.png

    Raspberry Pi

    The class Sound Synthesis at TU Berlin makes use of the Raspberry PI as a development and runtime system for sound synthesis in C++ (von Coler, 2017). Firtly, this is the cheapest way of setting up a computer pool with unified hard- and software. In addition, the PIs can serve as standalone synthesizers and sonification tools. All examples can be found in a dedicated software repository.

    The full development system is based on free, open source software. The examples are based on the JACK API for audio input and output, RtAudio for MIDI, as well as the liblo for OSC communication and libyaml-cpp for data and configuration files.

    The advantage and disadvantage of this setup is that every element needs to be implemented from scratch. In this way, synthesis algorithms can be understood in detail and customized without limitations. For quick solutions it makes sense to switch to a framework with more basic elements. The source code can also be used on any Linux system, provided the necessary libraries are installed.


    The Gain Example

    The gain example is the entry point for coding on the PI system: https://github.com/anwaldt/sound_synthesis_pi


    References

  • Henrik von Coler and David Runge. Teaching sound synthesis in c/c++ on the raspberry pi. In Proceedings of the Linux Audio Conference. 2017.
    [BibTeX▼]
  • The Karplus-Strong Algorithm

    The Karplus-Strong algorithm is not exactly a physical model, but it can be considered a preliminary stage to waveguides. The algorithm is based on a ringbuffer, filled with (white) noise, which is then manipulated. With very simple means, Karplus-Strong can synthesize sounds with the characteristics of plucked strings. Although not entirely realistic, the result has a intriguing individual character.


    The Ringbuffer

    Ringbuffers are the central element of the Karplus-Strong algorithm. As the name suggests, they are FIFO (first in - first out) buffers, with beginning and end connected. A ringbuffer with N samples can be visualized as follows:


    White Tone from White Noise

    If a ringbuffer is filled with a sequence of white noise, it can be used for creating a white tone - a harmonic sound with a strong overtone structure. Without resampling, the ring buffer can be shifted by one sample each $1/f_s$ seconds. The resulting pitch of the sound is then determined by the buffer size:

    $$f_0 = \frac{f_s}{N}$$

    For a sampling rate of $48000$ Hz, a ringbuffer with a length of $N=200$ samples, results in the following pitch:

    $$f_0 = \frac{ 48000 }{ 200 } = 240.0\ \mathrm{Hz}$$

    The sound of this harmonic signal is similar to a buzzer:


    Spectrum

    The spectrum of the white tone includes all harmonics up to the Nyquist frequency with a random amplitude. The overtone structure is individual for every white noise sequence, as is the timbre. These are three versions, started with an individual noise sequence of $N=400$ samples.

    Version 1

    Version 2

    Version 3