Síntesis de audio Python

Primero, importamos los módulos y bibliotecas necesarios. Importamos IPython para mostrar el reproductor de sonido, numpy para trabajar con matrices, matplotlib para trazar gráficos (lo haremos mientras generamos formas de onda básicas) y math para usar funciones matemáticas.

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

Establezca la frecuencia de muestreo. Aquí, establecemos el sample_rate con 22050.

sample_rate = 22050

Haz la forma de onda sinusoidal.

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

En este paso, definimos una función makesine(), que toma frecuencia y duración como parámetros. Utilizamos los métodos duration en numpy.linspace() y frequency en numpy.sin() para reutilizar formas de onda sinusoidales puras.

Tenga en cuenta que numpy.linspace() crea secuencias numéricas, o podemos decir que devuelve números/muestras espaciados uniformemente w.r.t. intervalo (comienzo, parada). Es similar a numpy.arange() pero toma un número de muestra (num) como parámetro en lugar de paso.

Puedes encontrar más sobre eso aquí.

Por otro lado, numpy.sin() calcula el seno trigonométrico para todas las x especificadas (una matriz de elementos).

Ejecute makesine().

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)

A continuación, ejecutamos makesine() varias veces para formar una nueva forma de onda con una frecuencia y una duración especificadas. Después de eso, usamos numpy.concatenate() para colocarlos todos juntos.

Puede encontrar el código fuente de trabajo completo a continuación con la salida respectiva.

Aquí está el código fuente completo.

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)

PRODUCCIÓN:

síntesis de audio de Python - ipython display.wav

Primero, importamos las bibliotecas necesarias: math para realizar funciones matemáticas y pyaudio para generar ondas.

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

Inicializa pyaudio.

PyAudio = pyaudio.PyAudio

Inicializar variables.

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 = ""

Aquí, inicializamos el bit_rate con 16000, que muestra el número de fotogramas por segundo. La frecuencia se establece en 500 Hz que denota las ondas por segundo (261.63=nota C4) mientras que la longitud se inicializa con 1.

Después de eso, usamos la función max() para encontrar el máximo de bit_rate y frequency+100 y asignamos el valor máximo a bit_rate. Luego, multiplicamos el bit_rate y la longitud, lo convertimos al tipo int usando la función int() y lo asignamos a number_of_frames.

A continuación, usamos el operador de módulo (%) para dividir number_of_frames con bit_rate y asignamos el resto a rest_frames. Finalmente, inicializamos wave_data con una cadena vacía.

Generar ondas.

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)

Aquí, usamos dos bucles for que iteran hasta el number_of_frames para generar ondas.

Grabar audio.

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()

Aquí, creamos una instancia de PyAudio, guardamos la referencia en p, y usamos esa referencia para abrir una secuencia usando el método open(), que grabará audio. A continuación, escribimos wave_data, detuvimos la transmisión y la cerramos. Finalmente, termine también la instancia PyAudio (p).

Puede leer sobre open(), write(), stop_stream() y close() aquí en detalle.

Aquí está el código fuente completo.

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()

Una vez que ejecutamos el código anterior, podemos escuchar una onda. Tenga en cuenta que no estamos guardando esta ola en un archivo .wav.

Puede leer aquí para aprender a guardar en un archivo .wav.