#+title: Sound Programming
#+summary: Programming sound in Live-Sequencer and ChucK
#+license: wtfpl, unless otherwise noted
#+startup: showall
#&toc

* Sound Programming

Much can be programmed, and that includes sound. In the digital world, sound is
typically represented by sequences of about 90 kB per second, so "printing"
sound is merely a matter of printing bytes. As such, any general purpose
language can be used to generate sounds.

However, it's boring to create a program that does nothing but print bytes, and
it's potentially difficult to make those bytes sound nice; we want abstractions
to simplify matters for us: instruments, drums, musical notes, and a high-level
program structure. Many programming languages have good libraries that allow us
to achieve just that, but to keep it simple we'll focus on how to program sound
in two languages designed to output sound: ChucK and Live-Sequencer.

Let's create some sounds.


* The square wave

We'll start with ChucK and a small square wave program:

#+BEGIN_SRC c
// Connect a square oscillator to the sound card.
SqrOsc s => dac;

// Set its frequency to 440 Hz.
440 => s.freq;

// Lower the volume.
0.1 => s.gain;

// Let it run indefinitely.
while (true) {
    1000::second => now;
}
#+END_SRC

ChucK is an imperative language. Instructions on how to install and run it can
be found on its [[http://chuck.cs.princeton.edu/][website]], along with other useful information. You can listen to
the above sound [[square.flac][here]].

To do the same in Live-Sequencer, we must find a square wave "instrument" and use
that.

#+BEGIN_SRC haskell
module SquareWave where

-- Basic imports.
import Prelude
import List
import Midi
import Instrument
import Pitch

-- The function "main" is run when the program is run.
              -- It returns a list of MIDI actions.
main = concat [ program lead1Square -- Use a square wave instrument.
              , cycle (             -- Keep playing the following forever.
                note 1000000 (a 4)  -- Play 1000000 milliseconds of the musical note A4
                )                      -- about 440 Hz.
              ];                    -- End with a semicolon.
#+END_SRC

Live-Sequencer differs from ChucK in that it is functional, but another major
difference is that while ChucK (in general) generates raw sound bytes,
Live-Sequencer generates so-called MIDI codes, which another program converts to
the actual audio. Live-Sequencer has a couple of funky features such as
highlighting which part of one's program is played; read about it and how to
install and run it at [[http://www.haskell.org/haskellwiki/Live-Sequencer][this wiki]]. You can listen to the above sound [[squarewave.flac][here]].


* Something more advanced

Let's try to create a small piece of music which can be expressed easily in
Live-Sequencer (listen [[melodyexample.flac][here]]):

#+BEGIN_SRC haskell
module MelodyExample where

import Prelude
import List
import Midi
import Instrument
import Pitch

-- Durations (in milliseconds).
en = 100;
qn = 2 * en;
hn = 2 * qn;
wn = 2 * hn;

twice x = concat [x, x];

main = cycle rpgMusic;

rpgMusic = concat [ partA g
                  , [Wait hn]
                  , twice (partB [b, d])
                  , partB [a, c]
                  , partA b
                  ];

partA t = concat [ program frenchHorn
                 , mel2 c e 4
                 , mel2 c e 5 -- The '=:=' operator merges two lists of actions
                   =:=        -- so that they begin simultaneously.
                   (concat [ [Wait wn]
                           , mel2 d t 3
                           ])
                 ];

partB firsts = concat [ program trumpet
                      , concat (map mel0 [c, e])
                        =:=
                        mergeMany (map mel1 firsts)
                      ];

-- Instrument-independent melodies.
mel0 x = concat [ note wn (x 3)
                , note hn (x 4)
                , note en (x 2)
                , [Wait wn]
                , twice (note qn (x 2))
                ];

mel1 x = concat [ note (wn + hn) (x 5)
                , note (hn + qn) (x 4)
                ];

mel2 x y n = concat [ twice (note qn (x 3))
                    , concatMap (note hn . y) [3, 4, 4]
                    , note wn (x n) =:= note wn (y n)
                    ];
#+END_SRC

When you play the program from the Live-Sequencer GUI, the code in use is
highlighted:

#&img;url=sound-highlight.png, width=640, center, caption=Highlighting of sound, screenshot 

The same could be expressed in ChucK, but the comparison wouldn't be fair. While
Live-Sequencer is designed for describing melodies, ChucK's purpose is sound
synthesis, which is more general. We'll create something more fitting of ChucK's
capabilities, while still focusing on the use of instruments (listen [[more_advanced.flac][here]]):

#+BEGIN_SRC c
// Background music for an old sci-fi horror B movie.

// Filters.
Gain g;
NRev reverb;

// Connect the Gain to the sound card.
g => dac;

// Connect the data sent to the sound card through the reverb filter back to the
// sound card.
adc => reverb => dac;

// Instruments.
Mandolin mandolin;
0.2 => mandolin.gain;
Sitar sitar;
0.8 => sitar.gain;
Moog moog;

// Instrument connections to the Gain.
mandolin => g;
sitar => g;
moog => reverb => g;

// Play a frequency 'freq' for duration 'dura' on instrument 'inst'.
fun void playFreq(StkInstrument inst, dur dura, int freq) {
    freq => inst.freq; // Set the frequency.
    0.1 => inst.noteOn; // Start playing with a velocity of 0.1.
    dura => now;
    0.1 => inst.noteOff; // Stop playing.
}

// Play a melody.
fun void a_melody(StkInstrument inst, int freq_offset) {
    int i;

    // Fork the command to play "in the background".
    spork ~ playFreq(moog, 600::ms, 400 - freq_offset);

    for (0 => i; i < 3; i++) {
        playFreq(inst, 200::ms, 220 + freq_offset + 10 * i);
    }

    // Create an array and use every element in it.
    [3, 4, 4, 5, 3] @=> int ns[];
    for (0 => i; i < ns.cap(); i++)
    {
        playFreq(inst, 100::ms, ns[i] * 132 + freq_offset);
    }
}

// Infinite sound loop of pseudo-random frequencies.
while (true) {
    spork ~ a_melody(moog, Math.random2(0, 30));
    Math.random2f(0.4, 0.9) => g.gain; // Adjust the gain.
    a_melody(mandolin, Math.random2(0, 350));
    a_melody(sitar, Math.random2(200, 360));
}
#+END_SRC


* Algorithmic composition

Why not have the computer generate the melody as well as the sound? That
*sounds* like a great idea!

Enter [[https: / / en.wikipedia.org / wiki / L-system][L-systems]]. An L-system has an alphabet and a set of rules, where each rule
is used to transform the symbol on the left-hand side to the sequence of symbols
on the right-hand side. We'll use this L-system to generate music:

#+BEGIN_SRC c
-- Based on https://en.wikipedia.org/wiki/L-system#Example_7:_Fractal_plant
Alphabet: X, F, A, B, P, M
Rules:
  X -> FMAAXBPXBPFAPFXBMX
  F -> FF
#+END_SRC

If we evaluate a L-system on a list, the system's rules are applied to each
element in the list, and results are concatenated to make a new list. If we
assign each symbol to a sequence of sounds and run the L-system a few times, we
get [[lsystem.flac][this]].

#+BEGIN_SRC haskell
module LSystem where

import Prelude
import List
import Midi
import Instrument
import Pitch

en = 100;
qn = 2 * en;
hn = 2 * qn;
wn = 2 * hn;

-- Define the L-System.
data Alphabet = X | F | A | B | P | M;
expand X = [F, M, A, A, X, B, P, X, B, P, F, A, P, F, X, B, M, X];
expand F = [F, F];
expand _ = [];

-- Map different instruments to different channels.
channelInsts = concat [ channel 0 (program celesta)
                      , channel 1 (program ocarina)
                      , channel 2 (program sitar)
                      ];

-- Define the mappings between alphabet and audio.
interpret X = [Wait hn];
interpret F = channel 0 (note qn (c 4));
interpret A = channel 1 (note qn (a 5));
interpret B = channel 1 (note qn (f 5));
interpret P = channel 2 (note hn (a 3));
interpret M = channel 2 (note hn (f 3));

-- A lazily evaluated list of all iterations.
runLSystem expand xs = xs : runLSystem expand (concatMap expand xs);

-- The sound from a L-System.
getLSystemSound expand interpret iterations start
  = concatMap interpret (runLSystem expand start !! iterations);

-- Use the third iteration of the L-System, and start with just X.
main = channelInsts ++ getLSystemSound expand interpret 3 [X];
#+END_SRC

Using an L-system is one of many ways to take composition to a high
level. L-systems can be used to generate fractals, which are nice.

    
* And so on

Many abstractions in sound generation allow for fun sounds to happen. Interested
people might want to also take a look at e.g.  [[http://haskell.cs.yale.edu/euterpea-2/][Euterpea]], [[http://puredata.info/][Pure Data]], or [[http://csounds.com/][Csound]].

#&line

Originally published [[http://dikutal.dk/artikler/sound-programming][here]].
