# Prolog’s Makin’ Music – Part 1

### Interlude

Gather around everyone, and I’ll tell the story of how I sold my soul to the binary devil.

It all began a dark and gloomy night. I’ve had one too many to drink – coffee, that is – and found it hard to concentrate on anything else than the splashing rain. The murky light played tricks on my eyes, or so I thought. Dangling contours everywhere. The buzzing monitor didn’t help either. I stretched out my back with a loud, cracking sound and tried to suppress a yawn.

“Do you want the power to create music from thin air?”

A voice from nowhere. Surely I hadn’t had that much to drink. I held up my keyboard like a club, cursing myself for getting rid of the IBM model M keyboard in favor of an ergonomic one, and slowly turned my head in the direction of the voice. If there was an intruder, I wouldn’t go down without a fight.

“Who’s there?”, I cried.

After a long silence the voice finally answered:

“Do you want to make a deal?”

“A deal?!” I blurted out, getting rather annoyed by his impudence.

“I shall grant your computer the gift of making music. All I ask in return is that your next blog entry contains some steamy, bit-on-bit action that somehow involves the WAV format. Also, I shall need your soul for all eternity.”

Having run out of ideas, I had no choice but to accept his offer.

“Sure! Wait, no!… Who are you?”

A manic laughter followed. He vanished in a hazy puff of smoke and left. All that remained was a chilly wind and a feeling that I had somehow been cheated.

### Computer generated music

Now to the point: the goal of this and the following entries will be to create computer generated music in Prolog/Logtalk. That might sound (pun not intended – I can’t help it) like a tall order, but hopefully everything will become clearer once we’ve explicated some of the concepts in music theory. The outline is as follows:

• Step 1 – Generate audio.
• Step 2 – Generate tones from audio.
• Step 3 – Generate melodies from tones, with a suitable formalism such as a cellular automata or an L-system.

### Sound as oscillations

In order to generate music we first need to understand what sound is. Wikipedia says:

Sound is a mechanical wave that is an oscillation of pressure transmitted through a solid, liquid, or gas, composed of frequencies within the range of hearing and of a level sufficiently strong to be heard, or the sensation stimulated in organs of hearing by such vibrations.

Or to put it a bit more pragmatic: a sound is a series of frequencies. Of course, this is a bit too simplistic to be useful in practice. Among other things, we need to decide whether we’re interested in mono or stereo sound, how fine-grained each frequency should be and how fast they should be played.

So we have an idea of how sound should be represented. First we decide how it should be interpreted by the listener, and then we give out the actual frequencies. As one might suspect there exists a myriad of different formats for this purpose. One of the simplest is the WAV format, which we shall use in this project.

### Writing to binary files

WAV is a binary format, and thus consists of a sequence of integers of varying sizes. Hence the first step is to learn how one writes to binary files in Prolog. The bad news is that there only exists one ISO primitive for this purpose: $put\_byte/2$, which is not sufficient since it only works for single byte, signed integers. The good news is that we can get it to do what we want with some low-level bit-fiddling. Here’s the operations that we’ll need in order to produce a fully functional WAV file:

• Write 4 byte, unsigned integers in big endian format.
• Write 4 byte, unsigned integers in little endian format.
• Write 2 byte, unsigned integers in little endian format.
• Write 2 byte, signed integers in little endian format.

It would be nice if we could handle this in a uniform way, so that the underlying details of how one should use $put\_byte/2$ can be postponed as far as possible. For this purpose we’ll introduce a data structure, $word$, that has the format:

$word(Byte\_Count, Endian, Integer)$

where $Byte\_Count$ is either $2$ or $4$, $Endian$ is either $big$ or $little$, and $Integer$ is a positive or negative integer. So to represent the number $135$  in the little endian format we would use:

$word(2, little, 135)$

while the number 1350 in big endian format would represented as:

$word(4, big, 1350)$

Simple, but it might feel kind of weird to represent such a low-level concept in this way. In most imperative languages we would of course explicitly declare the data as either char, short, int and so on, but this is the best we can do in Prolog (unless we create necessary bindings for the host language and borrow some datatypes). Next, we’re going to define $write\_word/2$ that writes a word to a stream. Let’s focus on 2 byte integers for the moment. A first attempt might look like:

```write_word(word(2, Endian, I), Stream) :-
put_byte(Stream, I).
```

Alas, this only works for single byte integers. If we want to write 2 bytes, we need to extract the individual bytes from the integer and call $put\_byte/2$ two times. This can be done with shifting and the bitwise and-operation.

```write_word(word(2, Endian, Bs), S) :-
X1 is Bs >> 8,
X2 is Bs /\ 0x00ff,
(  Endian = big ->
put_byte(S, X1),
put_byte(S, X2)
;  put_byte(S, X2),
put_byte(S, X1)
).
```

Note that we also check whether $Endian$ is $big$, and if so output the bytes in reversed order. This works fine for positive numbers, but what about signed, negative numbers? Since $put\_byte/2$ only works with positive numbers, we need to convert the negative number into a positive number that is still negative with respect to that byte range. This is actually rather easy to do since we’re using two’s complement numbers: if the number is negative, then add  a number such that the sum is the two’s complement of the absolute value of the negative number. The code will make this easier to understand:

```    write_word(word(2, Endian, Bs), S) :-
Bs >= 0,
X1 is Bs >> 8,
X2 is Bs /\ 0x00ff,
(  Endian = big ->
put_byte(S, X1),
put_byte(S, X2)
;  put_byte(S, X2),
put_byte(S, X1)
).
write_word(word(2, Endian, Bs), S) :-
Bs < 0,
Bs1 is Bs + 0xffff,
write_word(word(2, Endian, Bs1), S).
```

(Thanks to Pierpaolo Bernardi who showed me this trick on the SWI-Prolog mailing list!)
Update: Richard O’Keefe also showed a simpler solution that doesn’t need the explicit positive/negative test. It’s left as an exercise to the reader!

The code for 4 byte integers is rather similar and hence omitted.

### The WAV format

Now let’s focus on WAV. All my knowledge of the format stems from a single source (click for a useful, visual diagram). A WAV file consists of:

• A header containing the string “RIFF”, the remaining chunk size and the string “WAVE”.
• A format subchunk containing the string “fmt” (format), the remaining chunk size, the audio format, the number of channels, the sample rate, the byte rate, the block align and the number of bits that are used for each sample.
• A data subchunk that contains the string “data”, the remaining size of the subchunk and finally the actual data (the samples).

Don’t worry if some of these terms are unfamiliar or confusing. It’s not necessary to understand all the details. We begin by defining the number of samples, the number of channels, the bits per sample and the sample rate as facts:

```    num_samples(100000). %This value will of course differ depending on the audio data.
num_channels(1). %Mono.
bits_per_sample(16). %Implies that each sample is a 16 bit, signed integer.
sample_rate(22050).
```

All the other values can be derived from these parameters. For simplicity we’re going to produce a list of words that are later written with the help of $write\_word/2$. This can be done in any number of ways, but DCG’s are fairly straightforward in this case. The RIFF chunk is first. It takes the size of the data chunk as argument since it is needed in order to produce the size of the remaining chunk.

```    riff_chunk(Data_Chunk_Size) -->
riff_string,
chunk_size(Data_Chunk_Size),
wave_string.

riff_string --> [word(4, big, 0x52494646)].
wave_string --> [word(4, big, 0x57415645)].

chunk_size(Data_Chunk_Size) -->
{Size is Data_Chunk_Size + 36}, % Magic constant!
[word(4, little, Size)].
```

The end result will be a list of the form $[word(4, big, 0x52494646), ...]$. The format chunk follows the same basic structure:

```fmt_chunk -->
fmt_string,
sub_chunk1_size,
audio_format,
number_of_channels,
sample_rate,
byte_rate,
block_align,
bits_per_sample.

fmt_string -->  [word(4, big, 0x666d7420)]. %"fmt".

sub_chunk1_size --> [word(4, little, 16)]. %16, for PCM.

audio_format --> [word(2, little, 1)]. %PCM.

number_of_channels -->
[word(2, little, N)],
{num_channels(N)}.

.
.
. % And so on for all the remaining stuff.
```

The remaining data chunk is even simpler:

```data_chunk(Data_Chunk_Size) -->
data_string,
[word(4, little, Data_Chunk_Size)],
test_data.

test_data --> ... %This should generate a list of samples.
```

And finally, we say that a WAV file consists of a riff chunk, an fmt chunk and a data chunk:

```    wav_file -->
{num_samples(N),
bits_per_sample(BPS),
num_channels(Cs),
Data_Chunk_Size is N*BPS*Cs/8},
riff_chunk(Data_Chunk_Size),
fmt_chunk,
data_chunk(Data_Chunk_Size).
```

It is used in the following way:

```    output(File) :-
open(File, write, S, [type(binary)]),
%Call the DCG, get a list of words as result.
phrase(wav_file, Data),
%Write the list of words.
write_data(Data, S),
close(S).

write_data([], _).
write_data([B|Bs], S) :-
write_word(B, S),
write_data(Bs, S).
```

As test data, we’re going to generate a 440HZ sine wave.

```    sine_wave(0) --> [].
sine_wave(N) -->
{N > 0,
sample_rate(SR),
N1 is N - 1,
%% Standard concert pitch, 440 Hz.
Freq is 440,
ScaleFactor is 2*pi*Freq/SR,
%% Needed since sin(X) returns an integer in [-1, 1], which
%% is barely (if at all) perceivable by the human ear. The
%% constant 32767 is used since we're dealing with 16 bit,
%% signed integers, i.e. the range of the samples is [-32768,
%% 32767].
VolumeFactor is 32767,
X is ScaleFactor*N,
Sample0 is sin(X),
%% Floor the sample. Otherwise we would end up with a floating
%% point number, which is not allowed.
Sample is floor(Sample0*VolumeFactor)},
[word(2, little, Sample)],
sine_wave(N1).
```

It’s not necessary to understand all the details, but the end result is a list of 2 byte words that represent a 440 HZ sine wave. You can listen to it here.

### Summary

We’re now able to write samples to WAV files. These samples can represent any tone or sound, so in theory we already have everything that’s needed to generate music. But representing a tune as millions and millions of samples is not very user-friendly and would make it more or less impossible to automatically generate anything interesting. For that we’re going to need further abstractions, and among other things define a sound bank that contains some common tones.

### Source code

The source code is available at https://gist.github.com/955626.

### 9 responses to “Prolog’s Makin’ Music – Part 1”

1. Jensan says :

Nothing beats the sound of sine wave in the morning.

Interesting solution!

• victorlagerkvist says :

But, to be fair, I have the brilliant programmers behind http://code.google.com/p/faos/ to thank for almost everything!

• Jensan says :

That FAOS looks too good to be true! Is it true it does everything, and more? And that you can slide it under your bed?

2. victorlagerkvist says :

That, and much, much more! But I can’t help but wonder if it will ever be finished…

• vinh says :

bien me di may

3. thanosQR says :

really interesting; i think i’ll play with the code if i have time :b

• victorlagerkvist says :

Well, you’ll just have to take time! What on earth could possibly be more important?

• thanosQR says :

a compiler in prolog for my class :b

4. site says :

I even have an idda for construction of a new facility to replace that evil place known as Gitmo (this
is very important because we don’t want to ceate a bad impression in thhe minds of our fellow members in the United Nations).
It also has LED flash that illuminates when the need arises.
Yes, tthis is the way of the world, but it doesn’t have to be your world.

Hi there! Someone in my Myspace grop shared
this websige with us so I came to take a look.
I’m definitely loving the information. I’m bookmarking
and will be tweeting his to my followers! Fantastic blog and brilliant design.