Python-Audiosynthese

Zuerst importieren wir die notwendigen Module und Bibliotheken. Wir importieren IPython, um den Soundplayer anzuzeigen, numpy für die Arbeit mit Arrays, matplotlib zum Zeichnen von Diagrammen (wir werden dies tun, während wir grundlegende Wellenformen erzeugen) und math, um mathematische Funktionen zu verwenden.

import IPython.display as ipd
import numpy
import math
import matplotlib.pyplot as plt

Stellen Sie die Abtastrate ein. Hier setzen wir die sample_rate mit 22050.

sample_rate = 22050

Machen Sie die Sinuswellenform.

def makesine(frequency, duration):
    t = numpy.linspace(0, duration, math.ceil(sample_rate * duration))
    x = numpy.sin(2 * numpy.pi * frequency * t)
    return x

In diesem Schritt definieren wir eine Funktion makesine(), die Frequenz und Dauer als Parameter nimmt. Wir verwenden duration in numpy.linspace() und frequency in numpy.sin()-Methoden, um reine Sinuswellenformen wiederzuverwenden.

Beachten Sie, dass numpy.linspace() numerische Sequenzen erstellt, oder wir können sagen, dass es Zahlen/Samples mit gleichen Abständen bzgl. Intervall (Start, Stop). Es ist ähnlich wie numpy.arange(), nimmt aber anstelle von step eine Sample-Nummer (num) als Parameter.

Mehr dazu finden Sie hier.

Andererseits berechnet numpy.sin() den trigonometrischen Sinus für alle angegebenen x (ein Array von Elementen).

Führen Sie makesine() aus.

output = numpy.array(())
y = makesine(261.63, 0.5)  # C for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(293.66, 0.5)  # D for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(329.63, 0.5)  # E for 0.5 seconds

output = numpy.concatenate((output, y))
ipd.Audio(output, rate=sample_rate)

Als nächstes führen wir makesine() mehrmals aus, um eine neue Wellenform mit der angegebenen Frequenz und Dauer zu bilden. Danach verwenden wir numpy.concatenate(), um sie alle zusammen zu platzieren.

Den vollständigen funktionierenden Quellcode finden Sie unten mit der jeweiligen Ausgabe.

Hier ist der komplette Quellcode.

import IPython.display as ipd
import matplotlib.pyplot as plt
import numpy
import math

sample_rate = 22050


def makesine(frequency, duration):
    t = numpy.linspace(0, duration, math.ceil(sample_rate * duration))
    x = numpy.sin(2 * numpy.pi * frequency * t)
    return x


output = numpy.array(())
y = makesine(261.63, 0.5)  # C for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(293.66, 0.5)  # D for 0.5 seconds

output = numpy.concatenate((output, y))
y = makesine(329.63, 0.5)  # E for 0.5 seconds

output = numpy.concatenate((output, y))
ipd.Audio(output, rate=sample_rate)

AUSGANG:

Python-Audiosynthese - ipython display.wav

Zuerst importieren wir die notwendigen Bibliotheken: math zum Ausführen mathematischer Funktionen und pyaudio zum Erzeugen von Wellen.

import math  # import needed modules
import pyaudio  # sudo apt-get install python-pyaudio

Initialisieren Sie pyaudio.

PyAudio = pyaudio.PyAudio

Variablen initialisieren.

bit_rate = 16000
frequency = 500
length = 1

bit_rate = max(bit_rate, frequency + 100)
number_of_frames = int(bit_rate * length)
rest_frames = number_of_frames % bit_rate
wave_data = ""

Hier haben wir die bit_rate mit 16000 initialisiert, was die Anzahl der Bilder pro Sekunde anzeigt. Die Frequenz ist auf 500 Hz eingestellt, was die Wellen pro Sekunde bezeichnet (261.63=C4-Ton), während die Länge mit 1 initialisiert ist.

Danach verwenden wir die Funktion max(), um das Maximum aus bit_rate und frequency+100 zu finden und weisen bit_rate den maximalen Wert zu. Dann multiplizieren wir bit_rate und length, wandeln es mit der Funktion int() in den Typ int um und weisen es number_of_frames zu.

Als nächstes verwenden wir den Modulo-Operator (%), um number_of_frames durch bit_rate zu dividieren und den Rest rest_frames zuzuweisen. Abschließend initialisieren wir wave_data mit einem leeren String.

Wellen erzeugen.

for x in range(number_of_frames):
    wave_data = wave_data + chr(
        int(math.sin(x / ((bit_rate / frequency) / math.pi)) * 127 + 128)
    )

for x in range(rest_frames):
    wave_data = wave_data + chr(128)

Hier haben wir zwei for-Schleifen verwendet, die bis zur number_of_frames iterieren, um Wellen zu erzeugen.

Ton aufnehmen.

p = PyAudio()
stream = p.open(
    format=p.get_format_from_width(1), channels=1, rate=bit_rate, output=True
)
stream.write(wave_data)
stream.stop_stream()
stream.close()
p.terminate()

Hier haben wir eine Instanz von PyAudio erstellt, die Referenz in p gespeichert und diese Referenz verwendet, um einen Stream mit der Methode open() zu öffnen, der Audio aufzeichnet. Als nächstes schrieben wir wave_data, stoppten den Stream und schlossen ihn. Beenden Sie abschließend auch die PyAudio-Instanz (p).

Über open(), write(), stop_stream() und close() können Sie hier im Detail nachlesen.

Hier ist der komplette Quellcode.

import math
import pyaudio

PyAudio = pyaudio.PyAudio

bit_rate = 16000
frequency = 500
length = 1

bit_rate = max(bit_rate, frequency + 100)
number_of_frames = int(bit_rate * length)
rest_frames = number_of_frames % bit_rate
wave_data = ""

for x in range(number_of_frames):
    wave_data = wave_data + chr(
        int(math.sin(x / ((bit_rate / frequency) / math.pi)) * 127 + 128)
    )

for x in range(rest_frames):
    wave_data = wave_data + chr(128)

p = PyAudio()
stream = p.open(
    format=p.get_format_from_width(1), channels=1, rate=bit_rate, output=True
)

stream.write(wave_data)
stream.stop_stream()
stream.close()
p.terminate()

Sobald wir den obigen Code ausführen, können wir eine Welle hören. Beachten Sie, dass wir diese Wave nicht in einer .wav-Datei speichern.

Sie können hier lesen, um mehr über das Speichern in einer .wav-Datei zu erfahren.