!pip install googletrans 
!pip install deepspeech
!pip install youtube-dl
!pip install librosa
!pip install ffmpeg-python

print('Hola a todos')

def esc(code):
     return f'\033[{code}m'

print(esc('36;1;4') + 'Bievenidos al taller introductorio de python aplicado al audio')

from googletrans import Translator 

texto_en_ingles = """Batteries included Rich collection of already existing bricks of classic numerical methods, plotting or data processing tools. We don’t want to re-program the plotting of a curve, a Fourier transform or a fitting algorithm. Don’t reinvent the wheel!
Easy to learn Most scientists are not payed as programmers, neither have they been trained so. They need to be able to draw a curve, smooth a signal, do a Fourier transform in a few minutes.
Easy communication To keep code alive within a lab or a company it should be as readable as a book by collaborators, students, or maybe customers. Python syntax is simple, avoiding strange symbols or lengthy routine specifications that would divert the reader from mathematical or scientific understanding of the code.
Efficient code Python numerical modules are computationally efficient. But needless to say that a very fast code becomes useless if too much time is spent writing it. Python aims for quick development times and quick execution times.
Universal Python is a language used for many different problems. Learning Python avoids learning a new software for each new problem."""

translate = Translator()
texto_español = translate.translate(texto_en_ingles, dest = 'es')

texto_español.text

for oracion in texto_español.text.split('\n'):
    print('-.-')
    print(oracion)


    

# esto 
nombre = 'hola'
#los comentarios sirven para ir explicando el codigo

#integer
numero = 2  
#float 
numero_con_coma = 2.5 
# #el booleano puede ser True or False
# #boolean 
booleano = True

#algunos operadores 
multiplicacion = 4 * 5
potencia = 4 ** 5
divisor = 10/6 
divisor_entero = 10//6

divisor

type(1 == 1)

#podemos guardar los datos en listas 
lista = ['a', 'b', 1, 3]
#podemos usar otros tipos de datos como 
tupla = ('a', 1)
lista_de_tuplas = [('juan', 10), ('María', 18)] 
triplet = ('a', 4, 5)
etc = (1, 2, 3, 4, 5, 6)
#diccionarios 
diccionario = {'k' : 34, 'f' : 35, 't':42}

diccionario

diccionario.keys()

diccionario.values()

asd = {'f':'asdasd', 4:56.7} 

asd.keys()

lista_de_diccionarios = [{'f':5},{'g':6}]

lista_de_diccionarios[0]

lista

lista[0:2]  

lista[-1]

alumnos = [('juan', 35, 2), ('hernan', 32, 5), ('maría', 33, 0)]

#texto también es iterable
alumnos[0][0][1]

lista_n = [1,2,3,4,5,6,7,8,9]

# start:stop:step
# start::step 
# start:stop 
# start :: 
# :: end

lista_n[2:5]

str(12.34)

max([1,2,3,4,5,16,5,4,3,11])

# Escribir una función que recibe la longitud del lado de un cuadrado y retorna el área del cuadrado
def areaSquare(lado): 
    resultado = lado ** 2
    print('tu resultado es ', resultado)
    return resultado

result = areaSquare(lado = 4)

# Escribir una función que recibe el largo, ancho y profundidad de un ”cuboide” y retorna el área de la superficie del ”cuboide”
def surfaceAreaCuboid(largo,ancho,profundidad): 
    superficie = 2 * (largo * ancho + largo * profundidad + ancho * profundidad)
    return superficie

areaSquare(3)

surfaceAreaCuboid(1,3,5)

import numpy as np
from scipy import signal
import random

array = np.array([[1,2,3,4,5],[1,2,3,4,4]])

array.max()

array.T

x = np.array([1., -1., -2., 3])

x[1]

x > 1

x[x > 0]

np.cos(x)

#Para reproducir audio en la Jupyter N.
from IPython.display import Audio, display
import numpy as np

#cantidad de puntos por segundo 
framerate = 44100
#cinco segundos de audio 
t = np.linspace(0,5,framerate*5)
f = 440
data = np.sin( 2*np.pi*f*t)

def simple_wave(f, t, framerate = 44100, A = 1):
    '''función simple para armar una onda sonora
        inputs:
            f: frecuencia, float
            t: tiempo, float
            framerate: sampleo
            A: amplitud, por default 1 
        return:
            onda: numpy array
    '''

    t = np.linspace(0, t, int(framerate*t))
    resultado = A*np.sin(2*np.pi*f*t)
    return resultado 

la440 = simple_wave(f=440, t=5)

Audio(data=la440, rate=44100)

#Escala musical 
n_0 = 440
#lista por comprension 
notas = [440*2**(n/12) for n in range(13)]

sonidos = [simple_wave(f, 2) for f in notas]

sonidos

Audio(sonidos[0], rate=44100)

Audio(sonidos[1], rate=44100)

#1, 3, 4, 5 y 7
#encontrar notas de la escala pentatónica mayor de La 
#la, La#, si, do, do#, re, re#, mi, fa, fa#, sol, sol#, la

len(sonidos)

posiciones = [0,4,5,7,11,12]
#indexado más lista por comprensión 
escala_pentatonica = [sonidos[i] for i in posiciones]

#juntamos las notas de la pentatónica
audio_concatenado = np.concatenate(escala_pentatonica)

Audio(audio_concatenado, rate=44100)

# solo de computadora 
# negra 1 segundo
tiempos = [1, 2, 0.5, 0.25, 0.25]*4
pentatonic_freqs = [notas[i] for i in posiciones]*4
random.shuffle(pentatonic_freqs)
random.shuffle(tiempos)
solo = np.concatenate([simple_wave(f,t,44100) for f,t in zip(pentatonic_freqs, tiempos)])

Audio(solo, rate =44100)

#sum([simple_wave(f,4) for f in []])
acorde_do = simple_wave(261.63, 4, 44100) + simple_wave(349.228, 4, 44100) + simple_wave(392, 4, 44100)
acorde_fa = simple_wave(349.228, 2, 44100) + simple_wave(440, 2, 44100) + simple_wave(261.63*2, 2, 44100)
acorde_sol = simple_wave(392, 2, 44100) + simple_wave(494, 2, 44100) + simple_wave(587.33, 2, 44100)

Audio(acorde_sol, rate=44100)

base = np.concatenate([np.concatenate([acorde_do, acorde_fa, acorde_sol]), np.concatenate([acorde_do, acorde_fa, acorde_sol])])

Audio(base, rate=44100)

musiquita = base + solo

Audio(musiquita, rate=44100)

#Para plotear
import matplotlib.pyplot as plt
plt.style.use('seaborn-darkgrid')
%matplotlib inline

plt.figure(figsize=(5,5))
la440 = simple_wave(440, 5, 44100)
t = np.linspace(0, 5, 44100*5)
plt.xlim(0, 0.005)
plt.plot(t, la440)
plt.grid()
plt.xlabel('tiempo')
plt.ylabel('amplitud')
plt.show()

#señal triangular 
t = np.linspace(0, 1, 44100)
#2*pi*f*t 
plt.xlim([0, 0.005])
triangle = signal.sawtooth(2 * np.pi * 800 * t, 0.5)
plt.plot(t, triangle)

t = np.linspace(0, 1, 500, endpoint=False)
square = signal.square(2 * np.pi * 5 * t)
plt.plot(t, square)
plt.ylim(-2, 2)

t = np.linspace(0, 5, 44100*5)
w = signal.chirp(t, f0=1, f1=1500, t1=5, method='quadratic' )
plt.plot(t, w)
plt.xlim([0, 2])
plt.xlabel('t (sec)')
plt.show()

Audio(w, rate=44100)

#Armar una señal compleja con una función seno.
def simple_cos_wave(f, t, framerate, A = 1):
    '''Funcion para crear una onda cos
        inputs:
        f = frecuencia, int 
        t = tiempo, int 
        A = amplitud, int
        return:
        wave = onda senoidal, np.array
    '''
    t = np.linspace(0, t, framerate*t)
    return A*np.cos(2*np.pi*f*t)

cos_1 = simple_cos_wave(300, 5, 44100)
cos_2 = simple_cos_wave(400, 5, 44100)
sin_1 = simple_wave(500, 5, 44100)
sin_2 = simple_wave(200, 5, 44100)
suma_de_señales = cos_1 + cos_2 + sin_1 + sin_2 

plt.figure()
t = np.linspace(0, 5, 44100*5)
plt.plot(t, suma_de_señales)
plt.xlim([0, 0.05])
plt.grid()
plt.show()

Audio(suma_de_señales, rate=44100)

#distribución gauseana
mean = 0
std = 1 
framerate = 44100
seconds = 5
num_samples = seconds*framerate
noise = np.random.normal(mean, std, size=num_samples)
x = np.linspace(0, seconds, num_samples)
plt.plot(x, noise)
plt.show()

Audio(0.5*noise, rate=framerate)

sin_noise = sin_1 + noise 

Audio(sin_noise, rate = framerate)

from scipy.fft import fft, fftshift

def fourier_calculation(y, framerate):
    '''Aplicando fast fourier transform'''
    yf = fft(y)
    N = len(y)
    yf = 2.0/N *np.abs(yf[0:N//2])
    xf = np.linspace(0.0, 1/2*framerate, N//2)
    return yf, xf

yf, xf = fourier_calculation(w, framerate = 44100)
plt.xlim([0, 1000])
plt.plot(xf, yf)

yf, xf = fourier_calculation(suma_de_señales, framerate = 44100)
plt.plot(xf, yf)
plt.xlim([0, 1000])

a = plt.specgram(w, Fs=44100, cmap='jet')
plt.ylim([0,3000])
plt.colorbar()
plt.show()

f, t, Sxx = signal.spectrogram(w, fs=44100, nperseg=256*2, nfft=512*2)
plt.pcolormesh(t, f, Sxx, shading='gouraud', cmap='jet_r')
plt.ylim([0,2000])
plt.ylabel('Frequency [Hz]')
plt.xlabel('Time [sec]')
plt.show()

def plot_multiple(y, fs = 44100, plot_type = 'plotly'):
    '''Plotea primero la onda en dominio de tiempo, luego el espectro (FFT) y luego el espectrograma'''
    
    #Creo el espacio para plotear, una "figura" vacia
    plt.figure(figsize=(15,15))
    x = np.linspace(0, len(y)/fs, len(y))
    #Dividido en 3 filas y 1 columna, ploteo la onda en el 1er espacio
    plt.subplot(3, 1, 1)
    #plt.xlim([0, 0.005])
    plt.plot(x, y)
    #Pongo titulo al eje y
    plt.ylabel('Amplitude')
    #Grilla de fondo
    plt.grid()
    
    #FFT
    #n = len(w) = duración * framerate
    yf, xf = fourier_calculation(y, fs)
    #Plot FFT
    plt.subplot(3, 1, 2)
    #Ploteo las frecuencias positivas y sus valores, con un color RGBA
    plt.xlabel('Freq (Hz)')  
    plt.ylabel('|Y(freq)|')
    plt.xlim([0,2000])
    plt.plot(xf, yf)
    

    #plot spectogram
    if plot_type == 'scipy':
        plt.subplot(3, 1, 3)
        f, t, Sxx = signal.spectrogram(y, fs, scaling='density')
        plt.pcolormesh(t, f, Sxx, shading='gouraud', cmap='jet_r')
        plt.specgram(y, Fs =fs)
        plt.ylabel('Frequency [Hz]')
        plt.xlabel('Time [sec]')
        plt.ylim([0,2000])
        plt.show()
    else: 
        plt.subplot(3, 1, 3)
        a = plt.specgram(y, Fs=fs, NFFT=256*2, cmap='jet')
        plt.ylim([0,5000])
        plt.ylabel('Frequency [Hz]')
        plt.xlabel('Time [sec]')
        plt.colorbar()
        plt.show()

plot_multiple(w)

import numpy as np
import scipy.fftpack
plt.subplots(4, 1, figsize=(10, 10))
N = 22050
secs = 1
f = 200
x = np.linspace(0,secs, N*secs)
# sumamos señal mas ruido 
y = np.sin(2*np.pi*f*x) + np.random.random(N*secs) * 0.4
plt.subplot(4,1,1)
plt.plot(x[0:200],y[0:200])

#pasamos a dominio de frecuencias 
w = scipy.fftpack.rfft(y)
f = scipy.fftpack.rfftfreq(N*secs, x[1]-x[0])
spectrum = w**2
plt.subplot(4,1,2)
plt.plot(f[0:1000], spectrum[0:1000])

# sacamos frecuencias bajas con indexing booleano 
cutoff_idx = spectrum < (spectrum.max()/5)
w2 = w.copy()
w2[cutoff_idx] = 0
spectrum2 = w2**2
plt.subplot(4,1,3)
plt.plot(f[0:1000], spectrum2[0:1000])

#inversa de furier 
y2 = scipy.fftpack.irfft(w2)
plt.subplot(4,1,4)
plt.plot(x[0:200], y2[0:200])

from scipy.io import wavfile
import scipy.io

"""
To write this piece of code I took inspiration/code from a lot of places.
It was late night, so I'm not sure how much I created or just copied o.O
Here are some of the possible references:
https://blog.addpipe.com/recording-audio-in-the-browser-using-pure-html5-and-minimal-javascript/
https://stackoverflow.com/a/18650249
https://hacks.mozilla.org/2014/06/easy-audio-capture-with-the-mediarecorder-api/
https://air.ghost.io/recording-to-an-audio-file-using-html5-and-js/
https://stackoverflow.com/a/49019356
"""
from IPython.display import HTML, Audio
from google.colab.output import eval_js
from base64 import b64decode
import numpy as np
from scipy.io.wavfile import read as wav_read
import io
import ffmpeg

AUDIO_HTML = """
<script>
var my_div = document.createElement("DIV");
var my_p = document.createElement("P");
var my_btn = document.createElement("BUTTON");
var t = document.createTextNode("Press to start recording");

my_btn.appendChild(t);
//my_p.appendChild(my_btn);
my_div.appendChild(my_btn);
document.body.appendChild(my_div);

var base64data = 0;
var reader;
var recorder, gumStream;
var recordButton = my_btn;

var handleSuccess = function(stream) {
  gumStream = stream;
  var options = {
    //bitsPerSecond: 8000, //chrome seems to ignore, always 48k
    mimeType : 'audio/webm;codecs=opus'
    //mimeType : 'audio/webm;codecs=pcm'
  };            
  //recorder = new MediaRecorder(stream, options);
  recorder = new MediaRecorder(stream);
  recorder.ondataavailable = function(e) {            
    var url = URL.createObjectURL(e.data);
    var preview = document.createElement('audio');
    preview.controls = true;
    preview.src = url;
    document.body.appendChild(preview);

    reader = new FileReader();
    reader.readAsDataURL(e.data); 
    reader.onloadend = function() {
      base64data = reader.result;
      //console.log("Inside FileReader:" + base64data);
    }
  };
  recorder.start();
  };

recordButton.innerText = "Recording... press to stop";

navigator.mediaDevices.getUserMedia({audio: true}).then(handleSuccess);


function toggleRecording() {
  if (recorder && recorder.state == "recording") {
      recorder.stop();
      gumStream.getAudioTracks()[0].stop();
      recordButton.innerText = "Saving the recording... pls wait!"
  }
}

// https://stackoverflow.com/a/951057
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

var data = new Promise(resolve=>{
//recordButton.addEventListener("click", toggleRecording);
recordButton.onclick = ()=>{
toggleRecording()

sleep(2000).then(() => {
  // wait 2000ms for the data to be available...
  // ideally this should use something like await...
  //console.log("Inside data:" + base64data)
  resolve(base64data.toString())

});

}
});
      
</script>
"""

def get_audio():
  display(HTML(AUDIO_HTML))
  data = eval_js("data")
  binary = b64decode(data.split(',')[1])
  
  process = (ffmpeg
    .input('pipe:0')
    .output('pipe:1', format='wav')
    .run_async(pipe_stdin=True, pipe_stdout=True, pipe_stderr=True, quiet=True, overwrite_output=True)
  )
  output, err = process.communicate(input=binary)
  
  riff_chunk_size = len(output) - 8
  # Break up the chunk size into four bytes, held in b.
  q = riff_chunk_size
  b = []
  for i in range(4):
      q, r = divmod(q, 256)
      b.append(r)

  # Replace bytes 4:8 in proc.stdout with the actual size of the RIFF chunk.
  riff = output[:4] + bytes(b) + output[8:]

  sr, audio = wav_read(io.BytesIO(riff))

  return audio, sr

grabacion, sr = get_audio()

print(f"number of channels = {len(grabacion.shape)}")

length = grabacion.shape[0] / sr
print(f"length = {length}s")

plot_multiple(grabacion, sr)

plt.subplots(3, 1, figsize=(10, 10))
w = scipy.fftpack.rfft(grabacion)
f = scipy.fftpack.rfftfreq(len(grabacion), x[1]-x[0])
spectrum = w**2
plt.subplot(3,1,1)
plt.plot(f[0:1000], spectrum[0:1000])

cutoff_idx = spectrum < (spectrum.max()/5)
w2 = w.copy()
w2[cutoff_idx] = 0
spectrum2 = w2**2
plt.subplot(3,1,2)
plt.plot(f[0:30000], spectrum2[0:30000])

y2 = scipy.fftpack.irfft(w2)
plt.subplot(3,1,3)
plt.plot(x[0:200], y2[0:200])

Audio(y2, rate = sr)

!wget https://github.com/mozilla/DeepSpeech/releases/download/v0.9.1/deepspeech-0.9.1-models.pbmm
!wget https://github.com/mozilla/DeepSpeech/releases/download/v0.9.1/deepspeech-0.9.1-models.scorer

import deepspeech
from scipy.io import wavfile
import scipy.io
import numpy as np
import librosa

model_file_path = 'deepspeech-0.9.1-models.pbmm'
model = deepspeech.Model(model_file_path)

model.sampleRate()

speech, sr = get_audio()

speech = speech.astype(float)

librosa.output.write_wav('speech.wav', speech, sr)
y, s = librosa.load('speech.wav', sr=16000)

Audio(y,rate = s)

data16 = np.frombuffer(y, dtype=np.int16)

model.stt(data16)