¿Cómo reproducir y grabar audio en Python?

Como python puede hacer principalmente todo lo que uno pueda imaginar, incluida la reproducción y grabación de audio. Este artículo lo familiarizará con algunas bibliotecas de python y métodos directos que usan esas bibliotecas para reproducir y grabar sonido en python, con algunas funcionalidades más a cambio de algunas líneas de python adicionales previstas.

La mayoría de los archivos de audio están en formatos de archivo MP3 y WAV. Los archivos de audio WAV son el formato de audio digital más simple con altas tasas de grabación sin pérdidas, como resultado, los archivos WAV son grandes en comparación con otros formatos. Por la misma razón, se utilizan formatos MP3 que son de tamaño pequeño y comprimen archivos con muy poca diferencia en la calidad general del sonido. Además, es muy fácil convertir WAV a MP3 con software gratuito y de código abierto que está ampliamente disponible en Internet.

Reproducción de audio

A continuación se mencionan algunas bibliotecas de python con las que puede reproducir varios formatos de audio en python, incluidos formatos MP3, formatos WAV e incluso arrays NumPy. 

Método 1: Usar Playsound

El paquete listo para usar para reproducir archivos de audio con solo una línea de código. Se pueden reproducir archivos WAV o MP3 con él. Es un módulo de una sola función sin dependencias para reproducir sonido. 

La documentación de la biblioteca de PlaySound menciona que ha sido probada para archivos WAV y MP3, pero también puede funcionar con otros formatos de archivo cuya prueba se dejó en manos del usuario. El módulo playound contiene solo una cosa: la función (también llamada)playsound.

Las siguientes son las líneas de código para reproducir un archivo:

#import the library
from playsound import playsound
 
playsound('full_path/filename.mp3')

Producción:

Método 2: Usando Simpleaudio.

Ejemplo 1:

Es una biblioteca de Python multiplataforma para la reproducción de archivos WAV mono y estéreo sin otras dependencias para la reproducción de audio. Python 3.7 y versiones posteriores son oficialmente compatibles con macOS, Windows y Linux. 

El siguiente es el código simple para reproducir un archivo de formato .wav, aunque consume algunas líneas más de código en comparación con la biblioteca anterior:

# 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()

Producción:

Ejemplo 2:

simpleaudio se puede utilizar para reproducir objetos de bytes y arrays NumPy y Python utilizando simpleaudio.play_buffer() Las arrays Numpy se pueden utilizar para almacenar audio, pero existen algunos requisitos cruciales. Si van a almacenar audio estéreo, la array debe tener dos columnas que contengan un canal de datos de audio cada una. También deben tener un tipo D entero de 16 bits con signo y, en consecuencia, los valores de amplitud de la muestra deben estar entre -32768 y 32767. A continuación se muestra el código para generar una array NumPy y reproducirla usando simpleaudio.play_buffer().

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()

Producción:

Método 3: Usar winsound.

Ejemplo 1:

Es el módulo incorporado para acceder a un mecanismo básico de reproducción de sonido. Le permite reproducir archivos WAV únicamente (no es compatible con ningún otro formato de archivo) o emitir un pitido en su altavoz, pero solo funciona en Windows, como sugiere el nombre WINsound. Es el módulo incorporado, por lo que no se requiere instalación adicional.

#Import windound
import winsound
 
winsound.PlaySound(path_to_file, winsound.SND_FILENAME)

Producción:

Ejemplo 2:

También se puede utilizar para emitir un pitido en el altavoz o reproducir los sonidos predeterminados de Windows. En el siguiente código, se reproduce un pitido de 5000 Hz durante 1000 ms después del sonido de salida de Windows. 

#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)

Producción:

La principal desventaja de esta biblioteca es que es solo para usuarios del sistema operativo Windows y tampoco admite la reproducción de ningún otro archivo en lugar de los formatos WAV.

Método 4: Uso de dispositivo de sonido.

Este módulo de Python proporciona enlaces para la biblioteca PortAudio y algunas funciones convenientes para reproducir y grabar arrays NumPy que contienen señales de audio. Está disponible para los sistemas operativos Linux, macOS y Windows.

En el siguiente código, una línea que contiene ‘ sf.read() ‘ extrae todos los datos de audio sin procesar junto con la frecuencia de muestreo del archivo almacenada en su encabezado RIFF; y ‘ sounddevice.wait() ‘ garantiza que la secuencia de comandos finalice después de que ‘ sd.play(data,sr) ‘ termine de reproducir el audio.

# 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()

Producción:

Método 5: Usando pydub.

 Aunque pydub puede abrir y guardar fácilmente archivos WAV sin ninguna otra dependencia, debe tener al menos un paquete de reproducción de audio (simpleaudio, pyaudio, ffplay y avplay) preinstalado. Proporciona una implementación de Python pura para la manipulación de audio.

El siguiente código importa dos bibliotecas, la primera biblioteca para cargar el archivo y la segunda biblioteca para reproducir el archivo cargado. Además, se representan dos formas de cargar el archivo .wav.

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)

Producción:

Método 6: Usando pyaudio.

PyAudio es otra biblioteca de audio multiplataforma para Python. Si bien tiene más capacidad que la biblioteca de audio simple, como la grabación y la transmisión continua de audio, depende en gran medida de tener PortAudio, lo que resulta en una instalación más complicada. También proporciona enlaces de Python para PortAudio, la biblioteca de E/S de audio multiplataforma proporcionada por python-sounddevice. Con PyAudio, puede usar fácilmente Python para reproducir y grabar audio en una variedad de plataformas.

''' 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()

Producción:

Grabación de audio

Ahora solo cambia al modo de grabación del artículo. Pocas de las bibliotecas mencionadas anteriormente se usan para lo mismo, tanto la reproducción como la grabación se pueden explicar colectivamente, pero para muchas, puede resultar un poco confuso. Así que aquí se prefieren diferentes secciones dedicadas.

Nota: antes de usar cualquier biblioteca para grabar, asegúrese de que el micrófono de su dispositivo esté realmente conectado y que esté ENCENDIDO y no silenciado. uno puede verificar lo mismo usando las características y configuraciones del sistema operativo.

Método 1. Usando python-sounddevice

Esta biblioteca le permite reproducir (explicado anteriormente) y grabar arrays NumPy que contienen información de señal de audio. Este módulo requiere scipy o wavio para guardar el audio grabado, esto significa que la biblioteca scipy o wavio debe estar preinstalada junto con Numpy antes de usar este paquete para grabar.

# import required libraries
import sounddevice as sd
from scipy.io.wavfile import write
import wavio as wv
 
# Sampling frequency
frequency = 44400
 
# Recording duration in seconds
duration = 3.5
 
# to record audio from
# sound-device into a Numpy
recording = sd.rec(int(duration * frequency),
                   samplerate = freq, channels = 2)
 
# Wait for the audio to complete
sd.wait()
 
# using scipy to save the recording in .wav format
# This will convert the NumPy array
# to an audio file with the given sampling frequency
write("recording0.wav", freq, recording)
 
# using wavio to save the recording in .wav format
# This will convert the NumPy array to an audio
# file with the given sampling frequency
wv.write("recording1.wav", recording, freq, sampwidth=2)

Producción:

Como se indicó en la sección Audio, el dispositivo de sonido tenía una opción predeterminada para especificar el canal y la frecuencia para el uso repetido. Después de eso, no es necesario pasar esta opción como argumentos en el método sd.rec(). El siguiente código representa lo mismo y también se puede cambiar el tipo de datos de la array registrada del tipo predeterminado de float32 a otros.

import sounddevice as sd
 
sd.default.samplerate = 4400
sd.default.channels = 2
 
myrecording = sd.rec(int(duration * fs))
 
# change the data type: pass a new argument in .rec() of dtype
# myrecording = sd.rec(int(duration * fs), dtype='float64')
 
sd.wait()

Reproducción y grabación simultáneas

Para reproducir una array llamada my_arr y grabar al mismo tiempo. Aquí la frecuencia de muestreo es smpl_rate

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()

Método 2: Usando pyaudio.

Como arriba, reproducimos audio usando pyaudio leyendo pyaudio.Stream(). Para grabar audio debemos escribir a este mismo stream. El siguiente es el código para grabar unos segundos de audio y guardarlo en un archivo .wav:

import pyaudio
import wave
 
# Record in chunks of 1024 samples
chunk = 1024 
 
# 16 bits per sample
sample_format = pyaudio.paInt16 
chanels = 2
 
# Record at 44400 samples per second
smpl_rt = 44400 
seconds = 4
filename = "path_of_file.wav"
 
# Create an interface to PortAudio
pa = pyaudio.PyAudio() 
 
stream = pa.open(format=sample_format, channels=chanels,
                 rate=smpl_rt, input=True,
                 frames_per_buffer=chunk)
 
print('Recording...')
 
# Initialize array that be used for storing frames
frames = [] 
 
# Store data in chunks for 8 seconds
for i in range(0, int(smpl_rt / chunk * seconds)):
    data = stream.read(chunk)
    frames.append(data)
 
# Stop and close the stream
stream.stop_stream()
stream.close()
 
# Terminate - PortAudio interface
pa.terminate()
 
print('Done !!! ')
 
# Save the recorded data in a .wav format
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()

Producción: