pédalier
v0.9.16
pedalboard est une bibliothèque Python permettant de travailler avec l'audio : lecture, écriture, rendu, ajout d'effets, etc. Il prend en charge les formats de fichiers audio les plus populaires et un certain nombre d'effets audio courants, et permet également l'utilisation des formats VST3® et Audio Unit pour charger des instruments et effets logiciels tiers.
pedalboard a été conçu par l'Audio Intelligence Lab de Spotify pour permettre l'utilisation d'effets audio de qualité studio à partir de Python et TensorFlow. En interne chez Spotify, pedalboard est utilisé pour l'augmentation des données afin d'améliorer les modèles d'apprentissage automatique et d'aider à alimenter des fonctionnalités telles que AI DJ et AI Voice Translation de Spotify. pedalboard aide également au processus de création de contenu, permettant d'ajouter des effets à l'audio sans utiliser de station de travail audio numérique.
O(1)AudioStreamChorus , Distortion , Phaser , ClippingCompressor , Gain , LimiterHighpassFilter , LadderFilter , LowpassFilterConvolution , Delay , ReverbPitchShiftGSMFullRateCompressor , MP3CompressorResample , Bitcrushpedalboard.load_plugin )multiprocessing !tf.data ! pedalboard est disponible via PyPI (via Platform Wheels) :
pip install pedalboard # That's it! No other dependencies required.
Si vous êtes nouveau sur Python, suivez INSTALLATION.md pour un guide solide.
pedalboard est minutieusement testé avec Python 3.8, 3.9, 3.10, 3.11, 3.12 et 3.13.
manylinux et musllinux conçues pour x86_64 (Intel/AMD) et aarch64 (ARM/Apple Silicon)amd64 (x86-64, Intel/AMD) Remarque : Si vous préférez regarder une vidéo plutôt que de lire des exemples ou de la documentation, regardez Working with Audio in Python (feat. Pedalboard) sur YouTube .
from pedalboard import Pedalboard , Chorus , Reverb
from pedalboard . io import AudioFile
# Make a Pedalboard object, containing multiple audio plugins:
board = Pedalboard ([ Chorus (), Reverb ( room_size = 0.25 )])
# Open an audio file for reading, just like a regular file:
with AudioFile ( 'some-file.wav' ) as f :
# Open an audio file to write to:
with AudioFile ( 'output.wav' , 'w' , f . samplerate , f . num_channels ) as o :
# Read one second of audio at a time, until the file is empty:
while f . tell () < f . frames :
chunk = f . read ( f . samplerate )
# Run the audio through our pedalboard:
effected = board ( chunk , f . samplerate , reset = False )
# Write the output to our output file:
o . write ( effected )Remarque : Pour plus d'informations sur la façon de traiter l'audio via les plugins Pedalboard, y compris le fonctionnement du paramètre
reset, consultez la documentation depedalboard.Plugin.process.
# Don't do import *! (It just makes this example smaller)
from pedalboard import *
from pedalboard . io import AudioFile
# Read in a whole file, resampling to our desired sample rate:
samplerate = 44100.0
with AudioFile ( 'guitar-input.wav' ). resampled_to ( samplerate ) as f :
audio = f . read ( f . frames )
# Make a pretty interesting sounding guitar pedalboard:
board = Pedalboard ([
Compressor ( threshold_db = - 50 , ratio = 25 ),
Gain ( gain_db = 30 ),
Chorus (),
LadderFilter ( mode = LadderFilter . Mode . HPF12 , cutoff_hz = 900 ),
Phaser (),
Convolution ( "./guitar_amp.wav" , 1.0 ),
Reverb ( room_size = 0.25 ),
])
# Pedalboard objects behave like lists, so you can add plugins:
board . append ( Compressor ( threshold_db = - 25 , ratio = 10 ))
board . append ( Gain ( gain_db = 10 ))
board . append ( Limiter ())
# ... or change parameters easily:
board [ 0 ]. threshold_db = - 40
# Run the audio through this pedalboard!
effected = board ( audio , samplerate )
# Write the audio back as a wav file:
with AudioFile ( 'processed-output.wav' , 'w' , samplerate , effected . shape [ 0 ]) as f :
f . write ( effected ) from pedalboard import Pedalboard , Reverb , load_plugin
from pedalboard . io import AudioFile
from mido import Message # not part of Pedalboard, but convenient!
# Load a VST3 or Audio Unit plugin from a known path on disk:
instrument = load_plugin ( "./VSTs/Magical8BitPlug2.vst3" )
effect = load_plugin ( "./VSTs/RoughRider3.vst3" )
print ( effect . parameters . keys ())
# dict_keys([
# 'sc_hpf_hz', 'input_lvl_db', 'sensitivity_db',
# 'ratio', 'attack_ms', 'release_ms', 'makeup_db',
# 'mix', 'output_lvl_db', 'sc_active',
# 'full_bandwidth', 'bypass', 'program',
# ])
# Set the "ratio" parameter to 15
effect . ratio = 15
# Render some audio by passing MIDI to an instrument:
sample_rate = 44100
audio = instrument (
[ Message ( "note_on" , note = 60 ), Message ( "note_off" , note = 60 , time = 5 )],
duration = 5 , # seconds
sample_rate = sample_rate ,
)
# Apply effects to this audio:
effected = effect ( audio , sample_rate )
# ...or put the effect into a chain with other plugins:
board = Pedalboard ([ effect , Reverb ()])
# ...and run that pedalboard with the same VST instance!
effected = board ( audio , sample_rate ) Cet exemple crée un effet de pitch-shift retardé en exécutant plusieurs Pedalboards en parallèle sur le même audio. Les objets Pedalboard sont eux-mêmes des objets Plugin , vous pouvez donc les imbriquer autant que vous le souhaitez :
from pedalboard import Pedalboard , Compressor , Delay , Distortion , Gain , PitchShift , Reverb , Mix
passthrough = Gain ( gain_db = 0 )
delay_and_pitch_shift = Pedalboard ([
Delay ( delay_seconds = 0.25 , mix = 1.0 ),
PitchShift ( semitones = 7 ),
Gain ( gain_db = - 3 ),
])
delay_longer_and_more_pitch_shift = Pedalboard ([
Delay ( delay_seconds = 0.5 , mix = 1.0 ),
PitchShift ( semitones = 12 ),
Gain ( gain_db = - 6 ),
])
board = Pedalboard ([
# Put a compressor at the front of the chain:
Compressor (),
# Run all of these pedalboards simultaneously with the Mix plugin:
Mix ([
passthrough ,
delay_and_pitch_shift ,
delay_longer_and_more_pitch_shift ,
]),
# Add a reverb on the final mix:
Reverb ()
]) pedalboard prend en charge la diffusion audio en direct via un objet AudioStream , permettant une manipulation audio en temps réel en ajoutant des effets en Python.
from pedalboard import Pedalboard , Chorus , Compressor , Delay , Gain , Reverb , Phaser
from pedalboard . io import AudioStream
# Open up an audio stream:
with AudioStream (
input_device_name = "Apogee Jam+" , # Guitar interface
output_device_name = "MacBook Pro Speakers"
) as stream :
# Audio is now streaming through this pedalboard and out of your speakers!
stream . plugins = Pedalboard ([
Compressor ( threshold_db = - 50 , ratio = 25 ),
Gain ( gain_db = 30 ),
Chorus (),
Phaser (),
Convolution ( "./guitar_amp.wav" , 1.0 ),
Reverb ( room_size = 0.25 ),
])
input ( "Press enter to stop streaming..." )
# The live AudioStream is now closed, and audio has stopped.tf.data import tensorflow as tf
sr = 48000
# Put whatever plugins you like in here:
plugins = pedalboard . Pedalboard ([ pedalboard . Gain (), pedalboard . Reverb ()])
# Make a dataset containing random noise:
# NOTE: for real training, here's where you'd want to load your audio somehow:
ds = tf . data . Dataset . from_tensor_slices ([ np . random . rand ( sr )])
# Apply our Pedalboard instance to the tf.data Pipeline:
ds = ds . map ( lambda audio : tf . numpy_function ( plugins . process , [ audio , sr ], tf . float32 ))
# Create and train a (dummy) ML model on this audio:
model = tf . keras . models . Sequential ([ tf . keras . layers . InputLayer ( input_shape = ( sr ,)), tf . keras . layers . Dense ( 1 )])
model . compile ( loss = "mse" )
model . fit ( ds . map ( lambda effected : ( effected , 1 )). batch ( 1 ), epochs = 10 )Pour plus d'exemples, voir :
Les contributions au pedalboard sont les bienvenues ! Voir CONTRIBUTING.md pour plus de détails.
Pour citer pedalboard dans des travaux académiques, utilisez son entrée sur Zenodo :
Pour citer via BibTeX :
@software{sobot_peter_2023_7817838,
author = {Sobot, Peter},
title = {Pedalboard},
month = jul,
year = 2021,
publisher = {Zenodo},
doi = {10.5281/zenodo.7817838},
url = {https://doi.org/10.5281/zenodo.7817838}
} pedalboard est protégé par Copyright 2021-2024 Spotify AB.
pedalboard est sous licence GNU General Public License v3. pedalboard comprend un certain nombre de bibliothèques compilées statiquement et qui portent les licences suivantes :
PitchShift et les fonctions time_stretch utilisent la bibliothèque Rubber Band, qui bénéficie d'une double licence sous licence commerciale et GPLv2 (ou plus récente). FFTW est également inclus pour accélérer Rubber Band et est sous licence GPLv2 (ou plus récente).MP3Compressor utilise libmp3lame du projet LAME, qui est sous licence LGPLv2 et mis à niveau vers GPLv3 pour être inclus dans ce projet (comme autorisé par LGPLv2).GSMFullRateCompressor utilise libgsm, qui est sous licence ISC et compatible avec la GPLv3.VST est une marque déposée de Steinberg Media Technologies GmbH.
