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
#import the library 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 library import simpleaudio as sa # to check all the functions in succession # to verify the installation import simpleaudio.functionchecks as fc fc.run_all() # Path to file f_name = 'myfile.wav' # create WaveObject instances # directly from WAV files on disk wave_obj = sa.WaveObject.from_wave_file(f_name) # Audio playback play = wave_obj.play() # To stop after playing the whole audio 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 # Note frequencies first_freq = 400 nxt_freq = first_freq * 2 * * ( 7 / 12 ) # samples per second smpl_rate = 44100 # Note duration in seconds seconds = 3 # Generate array(timesteps) with # seconds*sample_rate steps, # ranging between 0 and seconds arr = np.linspace( 0 , seconds, seconds * smpl_rate, False ) # Generate a 400Hz Sine wave first_note = np.sin(first_freq * arr * 2 * np.pi) nxt_note = np.sin(nxt_freq * arr * 2 * np.pi) # merging the notes tape = np.hstack((first_note,nxt_note)) # normalizing to 16-bit range # after concatenating the note notes tape * = 32767 / np. max (np. abs (tape)) # Converting to 16-bit data tape = tape.astype(np.int16) # Start audio play = sa.play_buffer(tape, 1 , 2 , smpl_rate) # Wait for audio playback to finish before exiting 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 windound 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 windound import winsound #Beep at frequency = 5000 Hz for duration of 1000 ms winsound.Beep( 5000 , 1000 ) #windows exit sound after completion of above 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 libraries import sounddevice as sd import soundfile as sf # Extract data and sampling rate from file array, smp_rt = sf.read(path_of_file, dtype = 'float32' ) # start the playback sd.play(array, smp_rt) # Wait until file is done playing status = sd.wait() # stop the sound 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
''' Play a WAVE file ''' import pyaudio import wave filename = 'path-to_file.wav' # Set chunk size of 1024 samples per data frame chunk = 1024 # Open the soaudio/sound file af = wave. open (filename, 'rb' ) # Create an interface to PortAudio pa = pyaudio.PyAudio() # Open a .Stream object to write the WAV file # 'output = True' indicates that the # sound will be played rather than # recorded and opposite can be used for recording stream = pa. open ( format = pa.get_format_from_width(af.getsampwidth()), channels = af.getnchannels(), rate = af.getframerate(), output = True ) # Read data in chunks rd_data = af.readframes(chunk) # Play the sound by writing the audio # data to the Stream using while loop while rd_data ! = '': stream.write(rd_data) rd_data = af.readframes(chunk) # Close and terminate the stream stream.stop_stream() stream.close() pa.terminate() |
Output:
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.