How to Play and Record Audio in Python?
As python can mostly do everything one can imagine including playing and recording audio. This article will make you familiar with some python libraries and straight-forwards methods using those libraries for playing and recording sound in python, with some more functionalities in exchange for few extra intended python lines.
Most of the audio files are in MP3 and WAV file formats. WAV audio files are the simplest digital audio format with lossless high recording rates as a result WAV files are large compared to other formats. For the same reason, MP3 formats are used which are small in size and compresses files with very little difference to overall sound quality. Also, it is very easy to convert WAV to MP3 with open-source and free software which are widely available over the internet.
Playing Audio
Below mentioned are some python libraries with which you can play various audio formats in python including MP3 formats, WAV formats, and even NumPy arrays.
Method 1: Using Playsound
The ready-to-use package for playing audio files with only a single line of code. One can play WAV or MP3 files with it. It’s a single function module with no dependencies for playing sound.
Documentation of playsound library mentions that it has been tested for WAV and MP3 files, but may also work with other file formats whose testing was left up to the user. The playsound module contains only one thing – the function (also named) playsound.
Following are the code lines to play a file:
Python3
from playsound import playsound
playsound( 'full_path/filename.mp3' )
|
Output:
Method 2: Using Simpleaudio.
Example 1:
It is a cross-platform python library for playback of both mono and stereo WAV files with no other dependencies for audio playback. Python 3.7 and up is officially supported on macOS, Windows, and Linux.
Following is the simple code to play a .wav format file although it consumes few more lines of code compared to the above library:
Python3
import simpleaudio as sa
import simpleaudio.functionchecks as fc
fc.run_all()
f_name = 'myfile.wav'
wave_obj = sa.WaveObject.from_wave_file(f_name)
play = wave_obj.play()
play.wait_done()
play.stop()
|
Output:
Example 2:
simpleaudio can be utilized to play NumPy and Python arrays & bytes objects using simpleaudio.play_buffer() Numpy arrays can be used to store audio but there are some crucial requirements. If they are to store stereo audio, the array must have two columns that contain one channel of audio data each. They must also have a signed 16-bit integer d-type and the sample amplitude values must consequently fall between -32768 to 32767. Below is the code to generate a NumPy array and play it back using simpleaudio.play_buffer().
Python3
import numpy as np
import simplesound as sa
first_freq = 400
nxt_freq = first_freq * 2 * * ( 7 / 12 )
smpl_rate = 44100
seconds = 3
arr = np.linspace( 0 , seconds, seconds * smpl_rate, False )
first_note = np.sin(first_freq * arr * 2 * np.pi)
nxt_note = np.sin(nxt_freq * arr * 2 * np.pi)
tape = np.hstack((first_note,nxt_note))
tape * = 32767 / np. max (np. abs (tape))
tape = tape.astype(np.int16)
play = sa.play_buffer(tape, 1 , 2 , smpl_rate)
play.wait_done()
play.stop()
|
Output:
Method 3: Using winsound.
Example 1:
It’s the built-in module to access a basic sound playing mechanism. It allows you to play WAV files only (it does not support any other file formats) or beep your speaker, but it works only on Windows as the name suggests WINsound. It’s the built-in module so no extra installation is required.
Python3
import winsound
winsound.PlaySound(path_to_file, winsound.SND_FILENAME)
|
Output:
Example 2:
It can also be used to beep your speaker or Playing Windows default sound(s). In the following code beep sound of 5000Hz is played for 1000ms following the windows exit sound.
Python3
import winsound
winsound.Beep( 5000 , 1000 )
winsound.PlaySound( "SystemExit" , winsound.SND_ALIAS)
|
Output:
The main disadvantage of this library is that it is only for Windows operating system user and also do not support playback any other files rather than WAV formats.
Method 4: Using sounddevice.
This Python module provides bindings for the PortAudio library and a few convenience function(s) to play and record NumPy arrays that contain audio signals. It is available for Linux, macOS, and Windows operating systems.
In the following code, a line containing ‘ sf.read() ‘ extracts out all the raw audio data along with the sampling rate of the file as stored in its RIFF header; and ‘ sounddevice.wait() ‘ ensures that the script terminates after the ‘ sd.play(data,sr) ‘ finishes playing the audio.
Python3
import sounddevice as sd
import soundfile as sf
array, smp_rt = sf.read(path_of_file, dtype = 'float32' )
sd.play(array, smp_rt)
status = sd.wait()
sd.stop()
|
Output:
Method 5: Using pydub.
Even though pydub can easily open and save WAV files without any other dependencies, must need to have at least one audio playback package from (simpleaudio, pyaudio, ffplay, and avplay ) pre-installed. It gives pure python implementation for audio manipulation.
Following code imports two libraries, the first library to load the file and the second library to play the loaded file. Also, two ways are represented to load the .wav file.
Python3
from pydub import AudioSegment
from pydub.playback import play
tape = AudioSegment.from_file( 'path_to_myfile.wav' , format = 'wav' )
tape = AudioSegment.from_wav( 'path_to_myfile.wav' )
play(tape)
|
Output:
Method 6: Using pyaudio.
PyAudio is another cross-platform audio library for Python. While it has more capability than simpleaudio library, such as recording and continuous audio streaming, it largely depends on having PortAudio which results in more complicated installation. It also provides Python bindings for PortAudio, the cross-platform audio I/O library as provided by python-sounddevice. With PyAudio, you can easily use Python to play and record audio on a variety of platform.
Python3
import pyaudio
import wave
filename = 'path-to_file.wav'
chunk = 1024
af = wave. open (filename, 'rb' )
pa = pyaudio.PyAudio()
stream = pa. open ( format = pa.get_format_from_width(af.getsampwidth()),
channels = af.getnchannels(),
rate = af.getframerate(),
output = True )
rd_data = af.readframes(chunk)
while rd_data ! = '':
stream.write(rd_data)
rd_data = af.readframes(chunk)
stream.stop_stream()
stream.close()
pa.terminate()
|
Output:
Recording Audio
Now just switching to the recording mode of the article. Few of the above-mentioned libraries are used for the same, both playing and recording can be explained collectively but for many, it might get a bit confusing. So different dedicated sections are preferred here.
Note- Before using any library for recording, make sure the microphone of your device is actually connected and is ON also not Muted. one can check the same using operating system features and settings.
Method 1. Using python-sounddevice
This library allows you to play (explained above) and record NumPy arrays containing audio signal information. This module requires scipy or wavio to save the recorded audio, this means scipy or wavio library should be pre-installed along with Numpy before using this package for recording.
Python3
import sounddevice as sd
from scipy.io.wavfile import write
import wavio as wv
frequency = 44400
duration = 3.5
recording = sd.rec( int (duration * frequency),
samplerate = freq, channels = 2 )
sd.wait()
write( "recording0.wav" , freq, recording)
wv.write( "recording1.wav" , recording, freq, sampwidth = 2 )
|
Output:
As stated in the Audio section sounddevice had a default option to specify the channel and frequency for the repeated use. After that no need to pass this option as arguments in sd.rec() method. Following code represents the same along with one can also change the data type of recorded array from default type of float32 to others.
Python3
import sounddevice as sd
sd.default.samplerate = 4400
sd.default.channels = 2
myrecording = sd.rec( int (duration * fs))
sd.wait()
|
Simultaneous Playback & Recording
To Play an array named my_arr and Record at the same time. Here sample rate is smpl_rate
Python3
import sounddevice as sd
import numpy as np
smpl_rate = 44100
my_arr = np.random.uniform( - 1 , 1 ,smpl_rate)
recordd = sd.playrec(my_arr, smpl_rate, channels = 2 )
sd.wait()
|
Method 2: Using pyaudio.
As above, we played audio using pyaudio by reading the pyaudio.Stream(). To record audio we must write to this same stream. Following is the code to record a few seconds of audio and save the same to a .wav file:
Python3
import pyaudio
import wave
chunk = 1024
sample_format = pyaudio.paInt16
chanels = 2
smpl_rt = 44400
seconds = 4
filename = "path_of_file.wav"
pa = pyaudio.PyAudio()
stream = pa. open ( format = sample_format, channels = chanels,
rate = smpl_rt, input = True ,
frames_per_buffer = chunk)
print ( 'Recording...' )
frames = []
for i in range ( 0 , int (smpl_rt / chunk * seconds)):
data = stream.read(chunk)
frames.append(data)
stream.stop_stream()
stream.close()
pa.terminate()
print ( 'Done !!! ' )
sf = wave. open (filename, 'wb' )
sf.setnchannels(chanels)
sf.setsampwidth(pa.get_sample_size(sample_format))
sf.setframerate(smpl_rt)
sf.writeframes(b''.join(frames))
sf.close()
|
Output:
Last Updated :
25 Oct, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...