Jouer de l'audio avec Python
Comment puis-je lire de l'audio (ce serait comme un son d'une seconde) à partir d'un script Python?
Ce serait mieux si elle était indépendante de la plate-forme, mais tout d’abord, elle doit fonctionner sur un Mac.
Je sais que je pourrais simplement exécuter la commande afplay file.mp3 à partir de Python, mais est-il possible de le faire en Python brut? Je serais également mieux s'il ne s'appuyait pas sur des bibliothèques externes.
Vous pouvez trouver des informations sur l'audio Python ici: http://wiki.python.org/moin/Audio/
Il ne semble pas qu'il puisse lire les fichiers .mp3 sans bibliothèques externes. Vous pouvez convertir votre fichier .mp3 en un format .wav ou autre, ou utiliser une bibliothèque telle que PyMedia .
Votre meilleur choix est probablement d’utiliser pygame/SDL . C'est une bibliothèque externe, mais elle est très bien supportée sur toutes les plateformes.
pygame.mixer.init()
pygame.mixer.music.load("file.mp3")
pygame.mixer.music.play()
Vous trouverez une documentation plus spécifique sur le support du mélangeur audio dans la documentation pygame.mixer.music
Jetez un coup d’œil à Simpleaudio , qui est une bibliothèque relativement récente et légère à cet effet:
> pip install simpleaudio
Ensuite:
import simpleaudio as sa
wave_obj = sa.WaveObject.from_wave_file("path/to/file.wav")
play_obj = wave_obj.play()
play_obj.wait_done()
Veillez à utiliser des fichiers PCM 16 bits non compressés.
Dans pydub nous avons récemment choisi d'utiliser ffplay (via un sous-processus) depuis la suite d'outils ffmpeg, qui utilise SDL en interne.
Cela fonctionne pour nos besoins - en facilitant principalement le test des résultats du code pydub en mode interactif - mais il a ses inconvénients, comme le fait de faire apparaître un nouveau programme dans le dock sur mac.
J'ai lié l'implémentation ci-dessus, mais une version simplifiée suit:
import subprocess
def play(audio_file_path):
subprocess.call(["ffplay", "-nodisp", "-autoexit", audio_file_path])
L'indicateur -nodisp empêche ffplay d'afficher une nouvelle fenêtre et l'indicateur -autoexit force ffplay à quitter et à renvoyer un code de statut lorsque la lecture du fichier audio est terminée.
edit: pydub utilise maintenant pyaudio pour la lecture une fois installé et retourne à l'affichage pour éviter les inconvénients que j'ai mentionnés. Le lien ci-dessus montre également cette mise en œuvre.
Désolé pour la réponse tardive, mais je pense que c'est un bon endroit pour annoncer ma bibliothèque ...
Autant que je sache, la bibliothèque standard ne dispose que d’un module de lecture audio: ossaudiodev . Malheureusement, cela ne fonctionne que sous Linux et FreeBSD.
UPDATE: Il y a aussi winsound , mais cela dépend aussi de la plate-forme.
Pour quelque chose de plus indépendant de la plate-forme, vous devrez utiliser une bibliothèque externe.
Ma recommandation est le module sounddevice (mais méfiez-vous, je suis l'auteur).
Le paquet inclut la bibliothèque pré-compilée PortAudio pour Mac OS X et Windows, et peut être facilement installé avec:
pip install sounddevice --user
Il peut reproduire le son des tableaux NumPy, mais il peut également utiliser des tampons Python simples (si NumPy n’est pas disponible).
Pour lire un tableau NumPy, c'est tout ce dont vous avez besoin (en supposant que les données audio ont une fréquence d'échantillonnage de 44100 Hz):
import sounddevice as sd
sd.play(myarray, 44100)
Pour plus de détails, jetez un œil à la documentation .
Il ne peut pas lire/écrire des fichiers audio, vous aurez besoin d’une bibliothèque séparée pour cela.
Try playsound qui est un module simple fonction, en Python pur, sans aucune dépendance pour la reproduction des sons.
Installer via pip:
$ pip install playsound
Une fois que vous avez installé, vous pouvez l'utiliser comme ceci:
from playsound import playsound
playsound('/path/to/a/sound/file/you/want/to/play.mp3')
Si vous avez besoin d'une bibliothèque audio portable Python, essayez PyAudio . Il a certainement un port mac.
En ce qui concerne les fichiers mp3: c'est certainement faisable en Python "brut", seulement je crains que vous n'ayez à tout coder vous-même :). Si vous pouvez vous permettre une bibliothèque externe, j’ai trouvé quelques PyAudio - exemple PyLame ici.
Vous pouvez voir ceci: http://www.speech.kth.se/snack/
s = Sound()
s.read('sound.wav')
s.play()
La réponse d'Aaron semble être environ 10 fois plus compliquée que nécessaire. Faites cela si vous n’avez besoin que d’une réponse fonctionnant sous OS X:
from AppKit import NSSound
sound = NSSound.alloc()
sound.initWithContentsOfFile_byReference_('/path/to/file.wav', True)
sound.play()
Une chose ... ça revient tout de suite. Donc, vous voudrez peut-être aussi le faire si vous voulez que l'appel soit bloqué jusqu'à la fin du son.
from time import sleep
sleep(sound.duration())
Edit: J'ai pris cette fonction et l'ai combinée avec des variantes pour Windows et Linux. Le résultat est un module multi-plateforme pur en python, dépourvu de dépendances, appelé playsound . Je l'ai téléchargé sur Pypi.
pip install playsound
Puis lancez ça comme ça:
from playsound import playsound
playsound('/path/to/file.wav', block = False)
Les fichiers MP3 fonctionnent également sur OS X. WAV devrait fonctionner sur toutes les plateformes. Je ne sais pas quelles combinaisons de formats de plate-forme/fichier fonctionnent ou ne fonctionnent pas - je ne les ai pas encore essayées.
Également sous OSX - depuis SO , en utilisant la commande afplay de OSX:
import subprocess
subprocess.call(["afplay", "path/to/audio/file"])
UPDATE: Tout ce que cela fait est de spécifier comment faire ce que le PO voulait éviter de faire en premier lieu. Je suppose que j'ai posté ceci ici parce que ce que OP voulait éviter, c'était l'information que je cherchais. Oups.
Il est possible de lire de l’audio sous OS X sans bibliothèque tierce en utilisant un code analogue au code suivant. Les données audio brutes peuvent être entrées avec wave_wave.writeframes. Ce code extrait 4 secondes d'audio du fichier d'entrée.
import wave
import io
from AppKit import NSSound
wave_output = io.BytesIO()
wave_Shell = wave.open(wave_output, mode="wb")
file_path = 'SINE.WAV'
input_audio = wave.open(file_path)
input_audio_frames = input_audio.readframes(input_audio.getnframes())
wave_Shell.setnchannels(input_audio.getnchannels())
wave_Shell.setsampwidth(input_audio.getsampwidth())
wave_Shell.setframerate(input_audio.getframerate())
seconds_multiplier = input_audio.getnchannels() * input_audio.getsampwidth() * input_audio.getframerate()
wave_Shell.writeframes(input_audio_frames[second_multiplier:second_multiplier*5])
wave_Shell.close()
wave_output.seek(0)
wave_data = wave_output.read()
audio_stream = NSSound.alloc()
audio_stream.initWithData_(wave_data)
audio_stream.play()
Vous ne pouvez pas faire cela sans une bibliothèque non standard.
pour les utilisateurs de Windows qui se retrouvent dans ce fil, essayez pythonwin . PyGame a un support sonore. Pour l’audio de jeu avec accélération matérielle, vous devrez probablement appeler OpenAL ou un appareil similaire via des ctypes.
VLC propose quelques jolies liaisons python. Pour moi, cela fonctionnait mieux que pyglet, du moins sous Mac OS:
https://wiki.videolan.org/Python_bindings
Mais il s’appuie sur l’application VLC, malheureusement
Pypi a une liste de modules pour python en musique. Mon préféré serait jython car il contient plus de ressources et de bibliothèques pour la musique. Comme exemple de code pour jouer une seule note à partir du textbook :
# playNote.py
# Demonstrates how to play a single note.
from music import * # import music library
note = Note(C4, HN) # create a middle C half note
Play.midi(note) # and play it!
Essayez PySoundCard qui utilise PortAudio pour la lecture disponible sur de nombreuses plateformes ..__ De plus, il reconnaît les périphériques audio "professionnels" avec de nombreux canaux.
Voici un petit exemple tiré du Readme:
from pysoundcard import Stream
"""Loop back five seconds of audio data."""
fs = 44100
blocksize = 16
s = Stream(samplerate=fs, blocksize=blocksize)
s.start()
for n in range(int(fs*5/blocksize)):
s.write(s.read(blocksize))
s.stop()
import subprocess
f = './mySound.wav'
subprocess.Popen(['aplay','-q',f)
f = 'mySound.wav'
subprocess.Popen(['aplay','-q', 'wav/' + f)
man aplay
Pour lire un son de notification à l’aide de python, appelez un lecteur de musique, tel que vlc. VLC m'a invité à utiliser sa version en ligne de commande, cvlc, à la place.
from subprocess import call
call(["cvlc", "--play-and-exit", "myNotificationTone.mp3"])
Il faut que vlc soit préinstallé sur le périphérique. Testé sur Linux (Ubuntu 16.04 LTS); Exécuter Python 3.5.
Mac OS, j'ai essayé beaucoup de codes mais ça marche pour moi
import pygame
import time
pygame.mixer.init()
pygame.init()
pygame.mixer.music.load('fire alarm sound.mp3') *On my project folder*
i = 0
while i<10:
pygame.mixer.music.play(loops=10, start=0.0)
time.sleep(10)*to protect from closing*
pygame.mixer.music.set_volume(10)
i = i + 1
Ceci est le plus facile et le meilleur iv'e trouvé. Il prend en charge Linux/pulseaudio, Mac/coreaudio et Windows/WASAPI.
import soundfile as sf
import soundcard as sc
default_speaker = sc.default_speaker()
samples, samplerate = sf.read('bell.wav')
default_speaker.play(samples, samplerate=samplerate)
Voir https://github.com/bastibe/PySoundFile et https://github.com/bastibe/SoundCard pour des tonnes d'autres fonctionnalités super utiles.
Vous pouvez le faire simplement avec l’aide de cvlc - Je l’ai fait de cette façon:
import os
os.popen2("cvlc /home/maulo/selfProject/task.mp3 --play-and-exit")
/home/maulo/selfProject/task.mp3. C’est l’emplacement de mon fichier mp3 . À l’aide de "--play-and-exit", vous pourrez rejouer le son sans mettre fin au processus vlc.
Si vous êtes sur OSX, vous pouvez utiliser le module "os" ou "sous-processus" etc. pour appeler la commande OSX "play". Depuis le shell OSX, cela ressemble à
jouer "bah.wav"
Il commence à jouer dans environ une demi-seconde sur ma machine.