Python Audio Synthesis

First, we import the necessary modules and libraries. We import IPython to display sound player, numpy for working with arrays, matplotlib for plotting charts (we’ll be doing it while generating basic waveforms), and math to use mathematical functions.

import IPython.display as ipd
import numpy
import math
import matplotlib.pyplot as plt

Set the sample rate. Here, we set the sample_rate with 22050.

sample_rate = 22050

Make the sine waveform.

def makesine(frequency, duration):
    t = numpy.linspace(0, duration, math.ceil(sample_rate * duration))
    x = numpy.sin(2 * numpy.pi * frequency * t)
    return x

At this step, we define a function makesine(), which takes frequency and duration as parameters. We use duration in numpy.linspace() and frequency in numpy.sin() methods to reuse pure sine waveforms.

Note that the numpy.linspace() creates numeric sequences, or we can say it returns evenly spaced numbers/samples w.r.t. interval (start,stop). It is similar to the numpy.arange() but takes a sample number (num) as a parameter instead of step.

You can find more on that here.

On the other hand, numpy.sin() calculates the trigonometric sine for all the specified x (an array of elements).

Run makesine().

output = numpy.array(())
y = makesine(261.63, 0.5)  # C for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(293.66, 0.5)  # D for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(329.63, 0.5)  # E for 0.5 seconds

output = numpy.concatenate((output, y))
ipd.Audio(output, rate=sample_rate)

Next, we execute makesine() multiple times to form a new waveform with specified frequency and duration. After that, we use numpy.concatenate() to place all of them together.

You can find the complete working source code below with the respective output.

Here is the complete source code.

import IPython.display as ipd
import matplotlib.pyplot as plt
import numpy
import math

sample_rate = 22050


def makesine(frequency, duration):
    t = numpy.linspace(0, duration, math.ceil(sample_rate * duration))
    x = numpy.sin(2 * numpy.pi * frequency * t)
    return x


output = numpy.array(())
y = makesine(261.63, 0.5)  # C for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(293.66, 0.5)  # D for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(329.63, 0.5)  # E for 0.5 seconds

output = numpy.concatenate((output, y))
ipd.Audio(output, rate=sample_rate)

OUTPUT:

python audio synthesis - ipython display.wav

First, we import necessary libraries: math for performing mathematical functions and pyaudio for generating waves.

import math  # import needed modules
import pyaudio  # sudo apt-get install python-pyaudio

Initialize pyaudio.

PyAudio = pyaudio.PyAudio

Initialize variables.

bit_rate = 16000
frequency = 500
length = 1

bit_rate = max(bit_rate, frequency + 100)
number_of_frames = int(bit_rate * length)
rest_frames = number_of_frames % bit_rate
wave_data = ""

Here, we initialized the bit_rate with 16000, which shows the number of frames per second. The frequency is set to 500 Hz denoting the waves per second (261.63=C4-note) while length is initialized with 1.

After that, we use the max() function to find the maximum from bit_rate and frequency+100 and assign the maximum value to bit_rate. Then, we multiply the bit_rate and length, convert it to int type using the int() function and assign it to number_of_frames.

Next, we use the modulo operator (%) to divide number_of_frames with bit_rate and assign the remainder to rest_frames. Finally, we initialize wave_data with an empty string.

Generate waves.

for x in range(number_of_frames):
    wave_data = wave_data + chr(
        int(math.sin(x / ((bit_rate / frequency) / math.pi)) * 127 + 128)
    )

for x in range(rest_frames):
    wave_data = wave_data + chr(128)

Here, we used two for loops that iterate until the number_of_frames to generate waves.

Record audio.

p = PyAudio()
stream = p.open(
    format=p.get_format_from_width(1), channels=1, rate=bit_rate, output=True
)
stream.write(wave_data)
stream.stop_stream()
stream.close()
p.terminate()

Here, we created an instance of PyAudio, saved the reference in p, and used that reference to open a stream using the open() method, which will record audio. Next, we wrote wave_data, stopped the stream, and closed it. Finally, terminate the PyAudio instance (p) as well.

You can read about open(), write(), stop_stream(), and close() here in detail.

Here is the complete source code.

import math
import pyaudio

PyAudio = pyaudio.PyAudio

bit_rate = 16000
frequency = 500
length = 1

bit_rate = max(bit_rate, frequency + 100)
number_of_frames = int(bit_rate * length)
rest_frames = number_of_frames % bit_rate
wave_data = ""

for x in range(number_of_frames):
    wave_data = wave_data + chr(
        int(math.sin(x / ((bit_rate / frequency) / math.pi)) * 127 + 128)
    )

for x in range(rest_frames):
    wave_data = wave_data + chr(128)

p = PyAudio()
stream = p.open(
    format=p.get_format_from_width(1), channels=1, rate=bit_rate, output=True
)

stream.write(wave_data)
stream.stop_stream()
stream.close()
p.terminate()

Once we execute the above code, we can hear a wave. Note that we are not saving this wave in a .wav file.

You may read here to learn about saving in a .wav file.