import wave

f=wave.open('/content/drive/My Drive/Colab Notebooks/colab_tutorials/file.wav','rb')

data = f.readframes(chunk)

import pyaudio  
import wave  

#define stream chunk   
chunk = 1024  

#open a wav format music  
f = wave.open("/home/ihrd/Avigyan/whitenoisegaussian.wav","rb")  
#instantiate PyAudio  
p = pyaudio.PyAudio()  
#open stream  
stream = p.open(format = p.get_format_from_width(f.getsampwidth()),  
                channels = f.getnchannels(),  
                rate = f.getframerate(),  
                output = True)  
#read data  
data = f.readframes(chunk)  

#play stream  
while data:  
    stream.write(data)  
    data = f.readframes(chunk)  

#stop stream  
stream.stop_stream()  
stream.close()  

#close PyAudio  
p.terminate()

import matplotlib.pyplot as plt

from scipy.fftpack import fft

from scipy.io import wavfile # get the api

import numpy as np  

fs, data = wavfile.read('/content/drive/MyDrive/Colab Notebooks/colab_tutorials/OAF_base_happy.wav')

plt.plot(data,'g')

plt.show()

from scipy.io import wavfile # get the api

import numpy as np

fs, data = wavfile.read('file.wav') # load the data

a = data.T[0] # this is a two channel soundtrack, I get the first track

b=[(ele/2**8.)*2-1 for ele in a] # this is 8-bit track, b is now normalized on [-1,1)

c = fft(a) # calculate fourier transform (complex numbers list)

d = len(c)/2  # you only need half of the fft list (real signal symmetry)

plt.plot(abs(c[:(d-1)]),'r') 

plt.show()

_wav_file_ = "africa-toto.wav"

def spectogram_librosa(_wav_file_):
    import librosa
    import pylab
    import numpy as np
    
    (sig, rate) = librosa.load(_wav_file_, sr=None, mono=True,  dtype=np.float32)
    pylab.specgram(sig, Fs=rate)
    pylab.savefig('spectrogram3.png')

def graph_spectrogram_wave(wav_file):
    import wave
    import pylab
    def get_wav_info(wav_file):
        wav = wave.open(wav_file, 'r')
        frames = wav.readframes(-1)
        sound_info = pylab.fromstring(frames, 'int16')
        frame_rate = wav.getframerate()
        wav.close()
        return sound_info, frame_rate
    sound_info, frame_rate = get_wav_info(wav_file)
    pylab.figure(num=3, figsize=(10, 6))
    pylab.title('spectrogram pylab with wav_file')
    pylab.specgram(sound_info, Fs=frame_rate)
    pylab.savefig('spectrogram2.png')


def graph_wavfileread(_wav_file_):
    import matplotlib.pyplot as plt
    from scipy import signal
    from scipy.io import wavfile
    import numpy as np   
    sample_rate, samples = wavfile.read(_wav_file_)   
    frequencies, times, spectrogram = signal.spectrogram(samples,sample_rate,nfft=1024)
    plt.pcolormesh(times, frequencies, 10*np.log10(spectrogram))
    plt.ylabel('Frequency [Hz]')
    plt.xlabel('Time [sec]')
    plt.savefig("spectogram1.png")
    

spectogram_librosa(_wav_file_)
#graph_wavfileread(_wav_file_)
#graph_spectrogram_wave(_wav_file_)

from __future__ import print_function

import scipy.io.wavfile as wavfile

import scipy

import scipy.fftpack

import numpy as np

from matplotlib import pyplot as plt

fs_rate, signal = wavfile.read("/content/drive/My Drive/Colab Notebooks/colab_tutorials/file.wav")

print ("Frequency sampling", fs_rate)

l_audio = len(signal.shape)

print ("Channels", l_audio)

if l_audio == 2:

    signal = signal.sum(axis=1) / 2

N = signal.shape[0]

print ("Complete Samplings N", N)

secs = N / float(fs_rate)

print ("secs", secs)

Ts = 1.0/fs_rate # sampling interval in time

print ("Timestep between samples Ts", Ts)

t = scipy.arange(0, secs, Ts) # time vector as scipy arange field / numpy.ndarray

FFT = abs(scipy.fft(signal))

FFT_side = FFT[range(N//2)] # one side FFT range

freqs = scipy.fftpack.fftfreq(signal.size, t[1]-t[0])

fft_freqs = np.array(freqs)

freqs_side = freqs[range(N//2)] # one side frequency range

fft_freqs_side = np.array(freqs_side)

plt.subplot(311)

p1 = plt.plot(t, signal, "g") # plotting the signal

plt.xlabel('Time')

plt.ylabel('Amplitude')

plt.subplot(312)

p2 = plt.plot(freqs, FFT, "r") # plotting the complete fft spectrum

plt.xlabel('Frequency (Hz)')

plt.ylabel('Count dbl-sided')

plt.subplot(313)

p3 = plt.plot(freqs_side, abs(FFT_side), "b") # plotting the positive fft spectrum

plt.xlabel('Frequency (Hz)')

plt.ylabel('Count single-sided')

plt.show()

import pygame
file = 'rp.mp3'
pygame.init()
pygame.mixer.init()
pygame.mixer.music.load(file)
pygame.mixer.music.play()
while pygame.mixer.music.get_busy(): 
    pygame.time.Clock().tick(10)