#UPDATED FREQUENCIES

import numpy

import sys

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

import waveIO

sr = 44100.

bpm = 148

dt=0.5

threshold = 25

#threshold = 1067

WINDOW_LENGTH = 4500

OVERLAP_PERCENT = 0.5 # 0 <= OVERLAP PERCENT < 1

# This dict holds the "ideal" values for each note in the Fourth octave.

# A wave will be said to correspond to a given note if its frequency is within 1%

# of the ideal values in this table, multiplied appropriately to give the frequency for the correct octave

note_freqs = {

}

#This will hold all our chopped up notes

# Each note consists of a list containing 5 sublists

# Each of those 5 sublists corresponds to an octave 1-5

# Octave 1 is the first element of the list, Octave 6 the sixth

# For example, notes_db["C"][2] will be a list of all wave chunks whose dominant frequency

# corresponds to a C3 note, that is, a C in the 3rd octave

notes_db = {

}

all_notes=[]

# Use a given tempo to determine the correct length of time for each chunk of wave

def compute_dt(bpm):

return dt

# Split a long wave into chunks of note_size size

# note size is given in terms of list elements, so it must be computed beforehand

def split_wave(wave, note_size):

return chunks

#places a wave chunk in the correct bin

def store_note(chunk):

frequency = freqs[idx] * (sr/2)

def print_notes():

print("{!s}{!s}: {!s}".format(note, i+1, len(notes_db[note][i])))

# Tests the sample wave I created in a different function. The first quarter of the file is just a ~440hz sin

# The second quarter is a roughly 554hz sin wave

# The third quarter is a roughly 659hz sin wave

def test_sample_wave(chunks):

print("Tests passed for sample wave!")

def build_song(musicfile, dt):

return song_wave

def apply_window_function(func, data, tau):

return result

#Since we only apply the function to a window-size piece at a time, the rectangular window function simply returns the window sized piece intact

def window_rectangular(wave_window):

return wave_window*1

def window_hanning(wave_window):

return result

def plot_notes():

plt.show()

if __name__ == '__main__':

WINDOW_FUNC = window_hanning

# read and parse each input wave

for i in range(1, len(sys.argv) - 2):

#read in the wave file and unpack its data

wave_data = waveIO.read_wav_file(sys.argv[i])

wave_data = waveIO.unpack(wave_data)

wave_time = len(wave_data)/sr

wave_chunks = []

#Instead of multiplying the entire wave by the windowing function, we can simply examine window-sized pieces of the wave at a time

#counting by WINDOW_LENGTH*(1-OVERLAP_PERCENT) allows adjustment of what percent of each window overlaps with the next

#Example: OVERLAP_PERCENT = 0 means the next window will start where the previous window ended

#Example: OVERLAP_PERCENT = 0.5 means the next window will start at the halfway mark of the previous window

#This is necessary when using nonrectangular window functions, to prevent loss of data

for i in range(0, len(wave_data), int(WINDOW_LENGTH*(1-OVERLAP_PERCENT))):

window = []

window.extend(wave_data[i:i+WINDOW_LENGTH])

#multiply by the window function

window = WINDOW_FUNC(window)

wave_chunks.append(window)

for i in range(len(wave_chunks)):

chunk = wave_chunks[i]

if len(chunk) != WINDOW_LENGTH:

continue

store_note(chunk)

print_notes()

plot_notes()

# read and parse the music file

musicfile = sys.argv[-2]

song = build_song(musicfile, WINDOW_LENGTH / float(sr))

waveIO.write_wav_file(sys.argv[-1], waveIO.pack(song))