/makingsounds

or, How to Make Music by Defining Air Pressure as a Function Of Time

Sound is created in a musical instrument by making something vibrate very quickly, such as a string or a reed. This movement compresses the air around them, which then spreads out over time. These changes in air pressure can then be heard as sound.

Speakers produce noise by wiggling a thin membrane up and down, controlled using an analogue signal, where high amplitude moves it in one direction and low in the opposite. Digital audio stores this analgoue signal as a list of amplitudes sampled over time, which is a format referred to as pulse-code modulation (PCM).

While it is possible to play sounds directly, this requires specific libraries depending on the environment and the programming language being used (for example, you can use love2d's sound module to create and play raw love2d sound data). On the other hand, writing to an audio file also usually needs libraries, due to the complexities of most audio formats. The canonical Wave file format avoids both of these problems, which is simple enough to be generated by a simple program in basically any programming language.

Canonical WAV File structure and lua function (towav) to generate them

• A description of the PCM WAVE file format
• Other description of the WAVE file format

The following is an example of a function named "towav" written in lua which returns a string that contains all the data that goes in a WAV file.

local function encode1(num)
	return string.char(math.floor(num) % 256)
end
local function encode2(num)
	return string.char(
		math.floor(num) % 256,
		math.floor(num / 256) % 256
	)
end
local function encode4(num)
	return string.char(
		math.floor(num) % 256,
		math.floor(num / 256) % 256,
		math.floor(num / 256 / 256) % 256,
		math.floor(num / 256 / 256 / 256) % 256
	)
end
function towav(sound, time)
	local rate = 16000
	local data = {}
	for i = 1, time * rate do
		data[i] = encode2( sound(i/rate) * 127*256 )
		-- uses 16 bit precision
	end
	return "RIFF"
		.. encode4(36 + time*rate*2)
		.. "WAVE"
		.. "fmt "
		.. encode4(16)
		.. encode2(1)
		.. encode2(1)
		.. encode4(rate)
		.. encode4(rate*2)
		.. encode2(2)
		.. encode2(16)
		.. "data"
		.. encode4(time*rate*2)
		.. table.concat(data,"")
end

The following code, assuming it is able to access the towav function, will generate a file called "out.wav" that has a single pure tone at 440 hertz, which is often used as the standard frequency for A4, the first A above middle C.

local soundlength = 5 --seconds long
function sound(t)
	return math.sin(t * 2*math.pi * 440)
end

local wavfile = open("out.wav")
if wavfile then
	wavfile:write(towav(sound, soundlength))
	wavfile:close()
end

Something to remember is that amplitudes must be kept between -1 and 1, or the sound will become distorted as it wraps around the number range.

Real Perfect Fifths

An idea from music theory is to use notes that approximate simple ratios between frequencies, for example perfect fifths, which approximate a ratio of 3 to 2. One fun thing that can be done with sounds generated directly with code however, is create audio of any pitch, even more precise than cents (cents = hundredths of a note = 12 thousandths of an octave). Therefore, it is possible to create tonally exact ratios, for example:

local soundlength = 4 --seconds long
local tones = {1, 2/3, 2/3*4/3, 2/3*4/3*3/2*4/5, 1}
function sound(t)
	--perfect tone changing each second
	return math.sin(t * 2*math.pi * 523 * tones[math.floor(t)+1])
end

This has a few problems, notably a popping sound between notes, caused by sharp jumps where the frequency changes, and the "instrument" being used is a single sine wave, which can be slightly off-putting.

To fix the first thing, we can multiply the sound by a value that goes to zero when the pitch changes (at each second), such as a sine wave squared, which creates a rythm and eliminates the popping sound. To improve how the 'instrument' sounds, we can use harmonics, adding together copies of the sound where it's frequency is divided by a whole number.

local soundlength = 4 --seconds long
local tones = {1, 2/3, 2/3*4/3, 2/3*4/3*3/2*4/5, 1}
function sound(t)
	local sum = 0
	for n=1,3 do
		sum = sum + math.sin(t * 2*math.pi * 523 * tones[math.floor(t)+1] / n) / 3
	end
	return sum * math.pow(math.sin(t * math.pi),2)
end

This produces something resembling music, which is impressive considering that it is such a small program.

---