Delta Sigma con audio

Usando los conceptos descritos para abrir un archivo de audio .wav, realice en python lo siguiente:

a) Codificador: Realice la codificación en ∑Δ para el audio del ejemplo, y crear el archivo correspondiente al resultado.

b) Decodificador: Reconstruya la señal de audio a partir del archivo del literal anterior, de ∑Δ a .wav, y pruebe su resultado ejecutando el archivo con un programa como windows media player.

c) Realice las observaciones correspondientes al proceso realizado.

Trabajo extra, opcional

d) Cree un archivo de audio en formato .wav dictando una frase como la mostrada, y repita el proceso anterior.

e) Realice las observaciones correspondientes al proceso realizado.

Anexo: Codificador
Se adjunta un algoritmo en python de referencia al que hay que añadir la parte de manejo del audio.

– En el bloque de ingreso complete las instrucciones para leer el archivo. Observe los nombres de las variables.

# Modulacion Delta - Codificador de audio
# entrada x(t), salida: ysalida[n]
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
import scipy.io.wavfile as waves
import scipy.signal as senal

# INGRESO
# archivo=......
# fsonido, sonido = ......

# PROCEDIMIENTO
# Analógica de referencia
deltaT=1/(2*np.pi*fsonido)
xanalog=sonido[:,0] # Canal izquierdo
xmax=np.max(xanalog)
nsonido=len(xanalog)
t0=0
tn=nsonido*deltaT
t=np.arange(0,tn,deltaT)

# Codificacion Sigma-Delta
salto=1 #usa todas las muestras sin saltar
deltaY=xmax//10
nd=nsonido//salto
td=np.arange(0,nd,1) # eje tiempo[n] digital
xdigital=np.zeros(nd,dtype=float)
ysalida=np.zeros(nd,dtype=int)
muestra=xanalog[0]
i=1
while not(i>=nd):
    muestra=xanalog[i*salto] # referencia analógica
    diferencia=muestra-xdigital[i-1]
    if (diferencia>0):
        bit=1
    else:
        bit=-1
    xdigital[i]=xdigital[i-1]+bit*deltaY
    ysalida[i]=bit
    i=i+1
fsalida=fsonido/salto
parametros=np.array([deltaT,deltaY,fsalida])

# SALIDA
print(ysalida)
print(parametros)
# Graba archivo
np.savetxt('sigmadelta_datos.txt',ysalida,fmt='%i')
np.savetxt('sigmadelta_parametros.txt',parametros)
# Grafico
#Escala y para el grafico
a=int(nsonido*0.35)       # RANGO ejex del gráfico
b=int(nsonido*0.355)
plt.figure(1)       # define la grafica
plt.suptitle('Codificador Sigma-Delta Audio.wav')
plt.subplot(311)    # grafica de 3x1 y subgrafica 1
plt.ylabel('x(t)')
xmax=np.max(xanalog)+0.1*np.max(xanalog)# rango en el eje y
xmin=np.min(xanalog)-0.1*np.max(xanalog)
plt.axis((a*deltaT, b*deltaT, xmin, xmax))
plt.plot(t[a:b],xanalog[a:b], 'g')
plt.ylabel('xanalogica[n]')
plt.subplot(312) # grafica de 3x1 y subgrafica 2
plt.ylabel('xdigital[n]')
mxa=np.max(xdigital[a:b])  # rango en el eje
mna=np.min(xdigital[a:b])
plt.axis((a,b,mxa,mna))
#plt.plot(td,xdigital,'bo')
plt.step(td[a:b],xdigital[a:b], where='post',color='m')
plt.subplot(313) # grafica de 3x1 y subgrafica 3
plt.ylabel('ysalida[n]')
plt.axis((a,b,-1.1,1.1))
plt.step(td[a:b],ysalida[a:b], where='post',color='b')
plt.show()

Anexo Decodificador

El resultado gráfico al decodificar el archivo de ∑Δ se muestra, se debe añadir la instrucción para generar el archivo de audio y poder escucharlo.

modifique la seccion de #Salida para crear el arhivo de audio con nombre: ‘sigmadeltaaudio.wav’.

# Modulacion Sigma-Delta Decodificador
# entrada yentrada[n], salida: x[t]
# propuesta:edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
import scipy.io.wavfile as waves

# INGRESO
yentrada=np.loadtxt('sigmadelta_datos.txt',dtype=int)
datos=np.loadtxt('sigmadelta_parametros.txt',dtype=float)
deltaD=datos[0]
deltaY=datos[1]
fsonido=datos[2]

# PROCEDIMIENTO
k=len(yentrada) # número de muestras para gráfica
# Arreglos para datos
xdigital=np.zeros(k, dtype='int16')
punto=np.zeros(k, dtype=int)
td=td=np.zeros(k, dtype=float) # eje n digital
# calcula los valores para digital
xdigital[0]=yentrada[0]
punto[0]=0
td[0]=0
for i in range(1,k):
 punto[i]=i
 td[i]=deltaD*i
 xdigital[i]=xdigital[i-1]+yentrada[i]*deltaY

# SALIDA
print(xdigital)
#Archivo de audio
# CREAR EL ARCHIVO DE AUDIO ***********************

#Gráfico
a=int(k*0.25) # RANGO ejex del gráfico
b=int(k*0.252)
plt.figure(1) # define la grafica
plt.suptitle('Decodifica Sigma_Delta')
plt.subplot(211) # grafica de 2x1 y subgrafica 1
plt.ylabel('entrada: y[n]')
plt.axis((a,b,-1.1,1.1))
#plt.plot(punto[a:b],yentrada[a:b],'b')
plt.step(punto[a:b],yentrada[a:b], where='post', color='b')
plt.subplot(212) # grafica de 2x1 y subgrafica 2
plt.ylabel('salida: x[t]')
xmax=np.max(xdigital[a:b]) # rango en el eje
xmin=np.min(xdigital[a:b])
plt.axis((a*deltaD,b*deltaD,xmin,xmax))
#plt.plot(td[a:b],xdigital[a:b],'m')
plt.step(td[a:b],xdigital[a:b], where='post', color='m')
plt.show()

La gráfica muestra solo el intervalo de tiempo entre a=0.25 y b=0.252 del total de tiempo del audio, el propósito es la observacion visual complementará a la de escuchar el audio resultante.