Pedalboard
v0.9.16
pedalboard ist eine Python-Bibliothek zum Arbeiten mit Audio: Lesen, Schreiben, Rendern, Hinzufügen von Effekten und mehr. Es unterstützt die gängigsten Audiodateiformate und eine Reihe gängiger Audioeffekte und ermöglicht außerdem die Verwendung der Formate VST3® und Audio Unit zum Laden von Softwareinstrumenten und -effekten von Drittanbietern.
pedalboard wurde vom Audio Intelligence Lab von Spotify entwickelt, um die Verwendung von Audioeffekten in Studioqualität in Python und TensorFlow zu ermöglichen. Intern wird pedalboard bei Spotify zur Datenerweiterung verwendet, um Modelle für maschinelles Lernen zu verbessern und Funktionen wie Spotifys AI DJ und AI Voice Translation zu unterstützen. pedalboard hilft auch bei der Erstellung von Inhalten und ermöglicht das Hinzufügen von Effekten zu Audio, ohne eine digitale Audio-Workstation zu verwenden.
O(1) -SpeichernutzungAudioStreamChorus , Distortion , Phaser , ClippingCompressor , Gain , LimiterHighpassFilter , LadderFilter , LowpassFilterConvolution , Delay , ReverbPitchShiftGSMFullRateCompressor , MP3CompressorResample , Bitcrushpedalboard.load_plugin )multiprocessing zu verwenden!tf.data Pipelines verwendet werden! pedalboard ist über PyPI (über Platform Wheels) verfügbar:
pip install pedalboard # That's it! No other dependencies required.
Wenn Sie neu bei Python sind, folgen Sie INSTALLATION.md, um eine ausführliche Anleitung zu erhalten.
pedalboard wurde gründlich mit Python 3.8, 3.9, 3.10, 3.11, 3.12 und 3.13 getestet.
manylinux und musllinux Räder für x86_64 (Intel/AMD) und aarch64 (ARM/Apple Silicon)amd64 (x86-64, Intel/AMD) Hinweis : Wenn Sie lieber ein Video ansehen möchten, als Beispiele oder Dokumentationen zu lesen, schauen Sie sich Working with Audio in Python (feat. Pedalboard) auf YouTube an .
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 )Hinweis : Weitere Informationen zur Audioverarbeitung über Pedalboard-Plugins, einschließlich der Funktionsweise des
resetParameters, finden Sie in der Dokumentation zupedalboard.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 ) In diesem Beispiel wird ein verzögerter Pitch-Shift-Effekt erzeugt, indem mehrere Pedalboards parallel auf demselben Audiosignal betrieben werden. Pedalboard Objekte sind selbst Plugin -Objekte, Sie können sie also beliebig verschachteln:
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 unterstützt das Streamen von Live-Audio über ein AudioStream -Objekt und ermöglicht so die Bearbeitung von Audio in Echtzeit durch Hinzufügen von Effekten in 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 -Pipelines 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 )Weitere Beispiele finden Sie unter:
Beiträge zum pedalboard sind willkommen! Weitere Informationen finden Sie unter CONTRIBUTING.md.
Um pedalboard in wissenschaftlichen Arbeiten zu zitieren, verwenden Sie den Eintrag auf Zenodo:
Zitieren über 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 unterliegt dem Copyright 2021-2024 von Spotify AB.
pedalboard ist unter der GNU General Public License v3 lizenziert. pedalboard enthält eine Reihe von Bibliotheken, die statisch kompiliert sind und die folgenden Lizenzen tragen:
PitchShift Plugin und time_stretch Funktionen nutzen die Rubber Band Library, die unter einer kommerziellen Lizenz und der GPLv2 (oder neuer) doppelt lizenziert ist. FFTW ist ebenfalls enthalten, um Rubber Band zu beschleunigen, und ist unter der GPLv2 (oder neuer) lizenziert.MP3Compressor Plugin verwendet libmp3lame aus dem LAME-Projekt, das unter der LGPLv2 lizenziert und zur Aufnahme in dieses Projekt auf die GPLv3 aktualisiert ist (wie von der LGPLv2 zugelassen).GSMFullRateCompressor -Plugin verwendet libgsm, das unter der ISC-Lizenz lizenziert und mit der GPLv3 kompatibel ist.VST ist eine eingetragene Marke der Steinberg Media Technologies GmbH.
