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.
The following is an example of a function named "towav" written in lua which returns a string containing the raw data of a potential 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.
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 for such a small program.