Jouer et enregistrer du son en Python – Real Python

Si vous voulez utiliser ou comment enregistrer du son en Python, vous êtes au bon endroit! Dans ce didacticiel, vous apprendrez à lire et à enregistrer des sons en Python en utilisant certaines des bibliothèques audio les plus populaires. Vous apprendrez tout d’abord les méthodes les plus simples de lecture et d’enregistrement du son, puis des bibliothèques offrant des fonctionnalités supplémentaires en échange de quelques lignes de code supplémentaires.

À la fin de ce tutoriel, vous saurez comment:

• Lecture de fichiers MP3 et WAV, ainsi que de nombreux autres formats audio
• Lecture de tableaux NumPy et Python contenant du son
• Enregistrer le son en utilisant Python
• Enregistrez vos enregistrements ou vos fichiers audio dans différents formats de fichiers

Pour une liste complète des bibliothèques Python liées à l'audio, consultez la page wiki sur l'audio en Python.

Lecture de fichiers audio

Ci-dessous, vous verrez comment lire des fichiers audio avec une sélection de bibliothèques Python. Certaines de ces bibliothèques vous permettent de lire divers formats audio, notamment les matrices MP3 et NumPy. Toutes les bibliothèques ci-dessous vous permettent de lire des fichiers WAV, certains avec quelques lignes de code en plus que d'autres:

• jouer son est le package le plus simple à utiliser si vous souhaitez simplement lire un fichier WAV ou MP3. Il n'offre aucune fonctionnalité autre que la lecture simple.

• simpleaudio vous permet de lire des fichiers WAV et des tableaux NumPy, et vous offre des options pour vérifier si un fichier est toujours en cours de lecture.

• Winsound vous permet de lire des fichiers WAV ou de biper vos haut-parleurs, mais cela ne fonctionne que sous Windows.

• python-sounddevice et pyaudio fournir des liaisons pour la bibliothèque PortAudio pour la lecture multiplate-forme de fichiers WAV.

• pydub a besoin pyaudio pour la lecture audio, mais avec ffmpeg installé, il vous permet de lire une large gamme de formats audio avec seulement quelques lignes de code.

Jetons un coup d’œil à ces bibliothèques pour la lecture audio une par une.

jouer son

jouer son est un «module Python pur, multi-plateformes, à fonction unique, sans dépendances pour la reproduction des sons».
Avec ce module, vous pouvez jouer un fichier son avec une seule ligne de code:

de jouer son importation jouer son

jouer son('monfichier.wav')

La documentation de jouer son indique qu'il a été testé sur des fichiers WAV et MP3, mais qu'il peut également fonctionner avec d'autres formats de fichier.

Cette bibliothèque a été mise à jour pour la dernière fois en juin 2017. Elle semble bien fonctionner au moment de la rédaction de cet article, mais il n’est pas clair si elle supportera toujours les nouvelles versions de Python.

simpleaudio

simpleaudio est une bibliothèque multi-plateforme pour la lecture de fichiers WAV (mono et stéréo) sans dépendance. Le code suivant peut être utilisé pour lire un fichier WAV et attendre la fin de la lecture du fichier avant de terminer le script:

importation simpleaudio comme sa

nom de fichier = 'monfichier.wav'
wave_obj = sa.WaveObject.from_wave_file(nom de fichier)
play_obj = wave_obj.jouer()
play_obj.wait_done()  # Attendez que le son ait fini de jouer

Les fichiers WAV contiennent un séquence de bits représentant les données audio brutes, ainsi que en-têtes avec métadonnées au format RIFF (Resource Interchange File Format).

Pour les enregistrements sur CD, la norme industrielle consiste à stocker chaque échantillon audio (un point de données audio individuel relatif à la pression atmosphérique) sous forme de 16 bits valeur, à 44100 échantillons par seconde.

Pour réduire la taille du fichier, il peut être suffisant de stocker certains enregistrements (par exemple de la parole humaine) à un taux d'échantillonnage plus faible, par exemple 8 000 échantillons par seconde, bien que cela signifie que les fréquences sonores les plus élevées risquent de ne pas être représentées avec autant de précision.

Quelques-unes des bibliothèques présentées dans ce tutoriel jouent et enregistrent octets objets, alors que d'autres utilisent Tableaux NumPy pour stocker des données audio brutes.

Les deux correspondent à une séquence de points de données pouvant être lus à une fréquence d'échantillonnage spécifiée afin de reproduire un son. Pour un octets objet, chaque échantillon est stocké sous la forme d'un ensemble de deux valeurs de 8 bits, alors que dans un tableau NumPy, chaque élément peut contenir une valeur de 16 bits correspondant à un seul échantillon.

Une différence importante entre ces deux types de données est que octets les objets sont immuables, tandis que Les tableaux NumPy sont mutables, ce qui rend ce dernier plus apte à générer des sons et à traiter des signaux plus complexes. Pour plus d'informations sur l'utilisation de NumPy, consultez nos didacticiels NumPy.

simpleaudio vous permet de jouer aux tableaux NumPy et Python et octets objets utilisant simpleaudio.play_buffer (). Assurez-vous que NumPy est installé pour que l'exemple suivant fonctionne, ainsi que simpleaudio. (Avec pépin installé, vous pouvez le faire en exécutant pip installer numpy depuis votre console.)

Pour plus d'informations sur l'utilisation pépin Pour installer des paquets, jetez un coup d’œil à Pipenv – Guide du nouvel outil d’emballage Python.

Ci-dessous, vous verrez comment générer un tableau NumPy correspondant à une tonalité de 440 Hz et le reproduire à l’aide de simpleaudio.play_buffer ():

importation numpy comme np
importation simpleaudio comme sa

la fréquence = 440  # Notre note jouée sera 440 Hz
fs = 44100  # 44100 échantillons par seconde
secondes = 3  # Remarque durée de 3 secondes

# Génère un tableau avec secondes * pas_échantillons, entre 0 et secondes
t = np.linspace(0, secondes, secondes * fs, Faux)

# Générer une onde sinusoïdale de 440 Hz
Remarque = np.péché(la fréquence * t * 2 * np.pi)

# Assurez-vous que la valeur la plus élevée est dans la plage 16 bits
l'audio = Remarque * (2**15 - 1) / np.max(np.abdos(Remarque))
# Convertir en données 16 bits
l'audio = l'audio.type(np.int16)

# Commencer la lecture
play_obj = sa.play_buffer(l'audio, 1, 2, fs)

# Attend la fin de la lecture avant de quitter
play_obj.wait_done()

Ensuite, voyons comment vous pouvez utiliser Winsound lire des fichiers WAV sur une machine Windows.

Winsound

Si vous utilisez Windows, vous pouvez utiliser le logiciel intégré. Winsound module pour accéder à ses machines sonores de base. La lecture d’un fichier WAV peut se faire en quelques lignes de code:

importation Winsound

nom de fichier = 'monfichier.wav'
Winsound.Jouer son(nom de fichier, Winsound.SND_FILENAME)

Winsound ne prend pas en charge la lecture de fichiers autres que les fichiers WAV. Il vous permet de faire bip-bip vos haut-parleurs en utilisant winsound.Beep (fréquence, durée). Par exemple, vous pouvez émettre une tonalité de 1000 Hz pendant 100 millisecondes avec le code suivant:

importation Winsound

Winsound.Bip(1000, 100)  # Bip à 1000 Hz pendant 100 ms

Ensuite, vous apprendrez à utiliser le python-sounddevice module pour la lecture audio multi-plateforme.

python-sounddevice

Comme indiqué dans sa documentation, python-sounddevice «Fournit des liaisons pour la bibliothèque PortAudio et quelques fonctions pratiques pour lire et enregistrer des tableaux NumPy contenant des signaux audio». Pour lire des fichiers WAV, numpy et fichier audio doivent être installés pour ouvrir les fichiers WAV en tant que tableaux NumPy.

Avec python-sounddevice, numpy, et fichier audio installé, vous pouvez maintenant lire un fichier WAV en tant que tableau NumPy et le lire:

importation périphérique audio comme Dakota du Sud
importation fichier audio comme sf

nom de fichier = 'monfichier.wav'
# Extraire les données et le taux d’échantillonnage du fichier
Les données, fs = sf.lis(nom de fichier, type='float32')  
Dakota du Sud.jouer(Les données, fs)
statut = Dakota du Sud.attendre()  # Attendre la fin de la lecture du fichier

La ligne contenant sf.read () extrait les données audio brutes, ainsi que le taux d'échantillonnage du fichier tel qu'il est stocké dans son en-tête RIFF, et sounddevice.wait () garantit que le script n'est terminé que lorsque le son est terminé.

Ensuite, nous allons apprendre à utiliser pydub jouer du son. Avec les bonnes dépendances installées, il vous permet de lire une large gamme de fichiers audio et vous offre plus d'options pour travailler avec l'audio que son python Est-ce que.

pydub

Bien que pydub pouvez ouvrir et sauvegarder des fichiers WAV sans aucune dépendance, vous devez avoir un package de lecture audio installé pour jouer de l’audio. simpleaudio est fortement recommandé, mais pyaudio, ffplay, et avplay sont des options alternatives.

Le code suivant peut être utilisé pour lire un fichier WAV avec pydub:

de pydub importation AudioSegment
de pydub.playback importation jouer

du son = AudioSegment.from_wav('monfichier.wav')
jouer(du son)

Afin de lire d’autres types audio, tels que des fichiers MP3, ffmpeg ou libav devrait être installé. Consultez la documentation de pydub pour des instructions. Comme alternative aux étapes décrites dans la documentation, ffmpeg-python fournit des liaisons pour ffmpeg, et peut être installé avec pip:

$ pip installer ffmpeg-python

Avec ffmpeg installé, la lecture d’un fichier MP3 ne nécessite que quelques modifications mineures dans notre code antérieur:

de pydub importation AudioSegment
de pydub.playback importation jouer

du son = AudioSegment.from_mp3('monfichier.mp3')
jouer(du son)

En utilisant le AudioSegment.from_file (nom du fichier, type de fichier) construction, vous pouvez jouer n’importe quel type de fichier audio ffmpeg les soutiens. Par exemple, vous pouvez lire un fichier WMA en utilisant le texte suivant:

du son = AudioSegment.from_file('monfichier.wma', 'wma')

En plus de la lecture de fichiers son, pydub vous permet d'enregistrer de l'audio dans différents formats de fichier (de plus amples informations à ce sujet ultérieurement), de découper l'audio, de calculer la longueur des fichiers audio, d'effectuer des fondus en entrée ou en sortie, et d'appliquer des fondus enchaînés.

AudioSegment.reverse () crée une copie de l’AudioSegment qui est lue à l’arrière, que la documentation décrit comme «utile pour Pink Floyd, le vissage et certains algorithmes de traitement audio».

pyaudio

pyaudio fournit des liaisons pour PortAudio, la bibliothèque d’entrées / sorties audio multiplate-forme. Cela signifie que vous pouvez utiliser pyaudio pour lire et enregistrer de l’audio sur diverses plates-formes, notamment Windows, Linux et Mac. Avec pyaudio, la lecture audio se fait en écrivant sur un .Courant:

importation pyaudio
importation vague

nom de fichier = 'monfichier.wav'

# Définir une taille de bloc de 1024 échantillons par trame de données
tronçon = 1024  

# Ouvrir le fichier son 
wf = vague.ouvrir(nom de fichier, 'rb')

# Créer une interface pour PortAudio
p = pyaudio.PyAudio()

# Ouvrir un objet .Stream pour écrire le fichier WAV dans
# 'output = True' indique que le son sera joué plutôt que enregistré
courant = p.ouvrir(format = p.get_format_from_width(wf.getampwidth()),
                canaux = wf.obtenir des canaux(),
                taux = wf.s'embrasser(),
                sortie = Vrai)

# Lire les données en morceaux
Les données = wf.readframes(tronçon)

# Jouer le son en écrivant les données audio dans le flux
tandis que Les données ! = '':
    courant.écrire(Les données)
    Les données = wf.readframes(tronçon)

# Fermer et terminer le flux
courant.Fermer()
p.mettre fin()

Comme vous l'avez peut-être remarqué, jouer des sons avec pyaudio est un peu plus complexe que de jouer des sons avec les bibliothèques déjà vues. Cela signifie que ce n'est peut-être pas votre premier choix si vous souhaitez simplement jouer un effet sonore dans votre application Python.

Cependant, parce que pyaudio vous donne plus de contrôle de bas niveau, il est possible d'obtenir et de définir des paramètres pour vos périphériques d'entrée et de sortie, et de vérifier la charge de votre CPU et la latence d'entrée ou de sortie.

Il vous permet également de lire et d’enregistrer de l’audio en mode de rappel, où une fonction de rappel spécifiée est appelée lorsque de nouvelles données sont requises pour la lecture ou disponibles pour l’enregistrement. Ces options font pyaudio une bibliothèque appropriée à utiliser si vos besoins audio vont au-delà de la simple lecture.

Maintenant que vous avez compris comment utiliser différentes bibliothèques pour lire de l’audio, il est temps de voir comment utiliser Python pour enregistrer de l’audio vous-même.

Enregistrement audio

le python-sounddevice et pyaudio Les bibliothèques fournissent des moyens d’enregistrer l’audio avec Python. python-sounddevice enregistre dans des tableaux NumPy et pyaudio enregistrements à octets objets. Ces deux éléments peuvent être stockés sous forme de fichiers WAV à l’aide du scipy et vague bibliothèques, respectivement.

python-sounddevice

python-sounddevice vous permet d'enregistrer de l'audio à partir de votre microphone et de le stocker sous forme de matrice NumPy. C'est un type de données pratique pour le traitement du son qui peut être converti au format WAV pour le stockage en utilisant le scipy.io.wavfile module. Assurez-vous d'installer le scipy module pour l'exemple suivant (pip installer scipy). Cela installe automatiquement NumPy comme l’une de ses dépendances:

importation périphérique audio comme Dakota du Sud
de scipy.io.wavfile importation écrire

fs = 44100  # Taux d'échantillonnage
secondes = 3  # Durée de l'enregistrement

mon enregistrement = Dakota du Sud.rec(int(secondes * fs), taux d'échantillonnage=fs, canaux=2)
Dakota du Sud.attendre()  # Attendez que l'enregistrement soit terminé
écrire('output.wav', fs, mon enregistrement)  # Enregistrer en fichier WAV 

pyaudio

Plus tôt dans cet article, vous avez appris à jouer des sons en lisant un pyaudio.Stream (). L'enregistrement audio peut être fait en écrivant dans ce flux à la place:

importation pyaudio
importation vague

tronçon = 1024  # Enregistrement en morceaux de 1024 échantillons
sample_format = pyaudio.paInt16  16 bits par échantillon
canaux = 2
fs = 44100  # Enregistrement à 44100 échantillons par seconde
secondes = 3
nom de fichier = "output.wav"

p = pyaudio.PyAudio()  # Créer une interface pour PortAudio

impression('Enregistrement')

courant = p.ouvrir(format=sample_format,
                canaux=canaux,
                taux=fs,
                cadres_per_buffer=tronçon,
                contribution=Vrai)

cadres = []  # Initialise un tableau pour stocker des cadres

# Stocker les données en morceaux pendant 3 secondes
pour je dans intervalle(0, int(fs / tronçon * secondes)):
    Les données = courant.lis(tronçon)
    cadres.ajouter(Les données)

# Arrête et ferme le flux 
courant.stop_stream()
courant.Fermer()
# Termine l'interface PortAudio
p.mettre fin()

impression('Enregistrement terminé')

# Sauvegarder les données enregistrées dans un fichier WAV
wf = vague.ouvrir(nom de fichier, 'wb')
wf.setnchannels(canaux)
wf.setsampwidth(p.get_sample_size(sample_format))
wf.setframerate(fs)
wf.les cadres d'écriture(b''.joindre(cadres))
wf.Fermer()

Maintenant que vous avez vu comment enregistrer de l'audio avec python-sounddevice et pyaudio, vous apprendrez à convertir votre enregistrement (ou tout autre fichier audio) en une gamme de formats audio différents.

Sauvegarde et conversion audio

Vous avez vu plus tôt que vous pouvez utiliser le scipy.io.wavfile module pour stocker les tableaux NumPy en tant que fichiers WAV. le Wavio De même, le module vous permet de convertir des fichiers WAV et des tableaux NumPy. Si vous voulez stocker votre audio dans un format de fichier différent, pydub et fichier audio pratiques, car ils vous permettent de lire et d’écrire une gamme de formats de fichiers populaires (tels que MP3, FLAC, WMA et FLV).

Wavio

Ce module dépend de numpy et vous permet de lire les fichiers WAV en tant que tableaux NumPy et d’enregistrer les tableaux NumPy en tant que fichiers WAV.

Pour enregistrer un tableau NumPy en tant que fichier WAV, vous pouvez utiliser wavio.write ():

importation Wavio

Wavio.écrire("myfile.wav", my_np_array, fs, sampwidth=2)

Dans cet exemple, my_np_array est un tableau NumPy contenant de l'audio, fs est la fréquence d'échantillonnage de l'enregistrement (généralement 44100 ou 44800 Hz), et sampwidth est la largeur d'échantillonnage de l'audio (le nombre d'octets par échantillon, généralement 1 ou 2 octets).

fichier audio

le fichier audio bibliothèque peut lire et écrire tous les formats de fichiers pris en charge par libsndfile. Bien qu’il ne puisse pas lire l’audio, il vous permet de convertir l’audio de et en FLAC, AIFF et quelques formats audio moins courants. Pour convertir un fichier WAV en FLAC, vous pouvez utiliser le code suivant:

importation fichier audio comme sf

# Extraire les données audio et le taux d’échantillonnage du fichier 
Les données, fs = sf.lis('monfichier.wav') 
# Enregistrer en tant que fichier FLAC au taux d'échantillonnage correct
sf.écrire('monfichier.flac', Les données, fs)  

Un code similaire fonctionnera pour la conversion entre d’autres formats de fichiers pris en charge par libsndfile.

pydub

pydub vous permet de sauvegarder l'audio dans n'importe quel format ffmpeg prend en charge, qui comprend presque tous les types audio que vous pourriez rencontrer dans votre vie quotidienne. Par exemple, vous pouvez convertir votre fichier WAV en MP3 avec le code suivant:

de pydub importation AudioSegment
du son = AudioSegment.from_wav('monfichier.wav')

du son.exportation('monfichier.mp3', format='mp3')

En utilisant AudioSegment.from_file () est une manière plus générale de charger des fichiers audio. Par exemple, si vous souhaitez reconvertir votre fichier MP3 au format WAV, vous pouvez procéder comme suit:

de pydub importation AudioSegment
du son = AudioSegment.from_file('monfichier.mp3', format='mp3')

du son.exportation('monfichier.wav', format='wav')

Ce code devrait fonctionner pour tout format de fichier audio ffmpeg les soutiens.

Comparaison des bibliothèques audio

Vous trouverez ci-dessous un tableau pratique comparant les fonctionnalités des bibliothèques abordées dans ce didacticiel:

Les bibliothèques incluses dans ce tutoriel sont choisies pour leur facilité d'utilisation et leur popularité. Pour une liste plus complète des bibliothèques audio pour Python, consultez la page wiki sur l'audio en Python.

Conclusion: Jouer et enregistrer du son en Python

Dans ce tutoriel, vous avez appris à utiliser certaines des bibliothèques audio les plus populaires pour lire et enregistrer de l'audio en Python. Vous avez également vu comment enregistrer votre audio dans différents formats.

Vous êtes maintenant capable de:

• Jouer une large gamme de formats audio, y compris les baies WAV, MP3 et NumPy
• Record audio de votre microphone à un tableau NumPy ou Python
• le magasin votre audio enregistré une gamme de différents formats, y compris WAV et MP3
• Convertir vos fichiers audio dans une gamme de formats audio différents

Vous disposez maintenant des informations dont vous avez besoin pour vous aider à choisir les bibliothèques à utiliser pour commencer à travailler avec l'audio en Python. Allez-y et développez des applications audio géniales!