Now returns frequencies + uneven songs are no longer an issue

new-process.py

@@ -9,6 +9,9 @@ import struct
 import librosa
 import heapq
 import scipy
+import os
+import random
+from time import sleep
 
 print("Starting...\n")
 
@@ -120,6 +123,40 @@ def filter_n_percent(song_name, offset, length, threshold, reduce, show):
 
     return song_data
 
+def filter_n_percent_serial(song_name, offset, n_iter, step, threshold):
+    # threshold is in ]0, 100]
+    # filter data associated with song_name to keep only the highest threshold% values
+
+    subprocess.run(["ffmpeg", "-ss", str(offset), "-t", str(offset+step*n_iter), "-i", song_name, "crop.wav"]) 
+
+    sample_rate, global_data = wavfile.read('crop.wav')
+
+    subprocess.run(["clear"])
+    subprocess.run(["rm", "crop.wav"])
+
+    for i in range(n_iter):
+        print(i, "/", n_iter)
+        song_data = global_data[int(i*step*sample_rate):int((i+1)*step*sample_rate)]
+
+        mx = max(song_data)
+        
+        is_locked = [False for i in range(len(song_data))]
+        x = int((len(song_data)*threshold)//100)
+        #print("X = ", x)
+
+        #print("Retreiving the", int(x), "/", len(song_data), "highest values")
+        elements = heapq.nlargest(int(x), enumerate(song_data), key=lambda x: x[1])
+        #print("Done")
+
+        for idx in range(len(elements)):
+            is_locked[elements[idx][0]] = True
+
+        for r in range(len(song_data)):
+            if(is_locked[r] == False):
+                global_data[r+int(i*step*sample_rate)] = 0
+
+    return global_data
+
 
 def write_to_file_thr(sample_rate, song_data, offset, threshold, filename):
     # write data to output file
@@ -188,14 +225,56 @@ def snap(data, sample_rate, bpm, divisor, show):
 def compress(Zxx):
     res = []
 
-
+def get_freq(song_name, offset, step, songlen, data):
-def void_freq(song_name, offset, songlen, increment, minfreq, maxfreq, upperthr, ampthr):
     fft_list = []
     times = []
     current_time = offset
     k = 0
 
-    subprocess.run(["ffmpeg", "-ss", str(offset), "-t", str(songlen-offset), "-i", song_name, "crop.wav"]) 
+    subprocess.run(["ffmpeg", "-ss", str(offset), "-t", str(offset+songlen), "-i", song_name, "crop.wav"]) 
+
+    sample_rate, global_data = wavfile.read("crop.wav")
+    #blit = int(len(global_data) / len(data))
+    blit = int(sample_rate*step)
+
+    subprocess.run(["clear"])
+    subprocess.run(["rm", "crop.wav"])
+
+    pfreq = scipy.fft.rfftfreq(blit, 1/sample_rate)
+
+    print("len : ", len(global_data))
+    print("len : ", len(data))
+
+    frequencies = [0 for s in range(len(data))]
+    print(len(pfreq))
+
+    for s in range(len(data)):
+        if(data[s] != 0):
+            pff = scipy.fft.rfft(global_data[int(s*len(global_data)/len(data)):int(44100*step+int(s*len(global_data)/len(data)))])
+            
+            mx = max(np.abs(pff))
+            for id in range(len(pff)):
+                if frequencies[s] == 0 and np.abs(pff[id]) == mx:
+                    frequencies[s] = pfreq[id]
+
+        elif s != 0:
+            frequencies[s] = 0
+
+    if(True):
+        plt.plot([t/1000 for t in range(len(data))], frequencies)
+        plt.grid()
+        plt.show()
+
+    return frequencies
+
+
+def void_freq(song_name, offset, songlen, increment, minfreq, maxfreq, upperthr, ampthr, ampfreq, ampval, leniency, write):
+    fft_list = []
+    times = []
+    current_time = offset
+    k = 0
+
+    subprocess.run(["ffmpeg", "-ss", str(offset), "-t", str(songlen+offset), "-i", song_name, "crop.wav"]) 
 
     sample_rate, global_data = wavfile.read("crop.wav")
     blit = int(sample_rate*increment)
@@ -219,13 +298,12 @@ def void_freq(song_name, offset, songlen, increment, minfreq, maxfreq, upperthr,
 
     print("FFT :", len(fft_list), "\nFFT[0] :", len(fft_list[0]), "\npfreq :", len(pfreq))
 
+    
     print("Finding global max...")
-    gmax = 0
+    
     for i in range(len(fft_list)):
-        #fft_list[i] = np.real(fft_list[i])
         for j in range(len(fft_list[i])):
-            if(np.real(fft_list[i][j]) > gmax):
+            fft_list[i][j] *= (1 + ampval/max(1, np.abs(pfreq[j] - ampfreq)))  
-                gmax = np.real(fft_list[i][j])
 
     print("Trimming...")
 
@@ -242,7 +320,8 @@ def void_freq(song_name, offset, songlen, increment, minfreq, maxfreq, upperthr,
             if(np.abs(fft_list[i][j]) < lmax/ampthr):
                 fft_list[i][j] = 0+0j
 
-    if(True):
+
+    if(write):
         res = []
         print("Converting...")
         for i in range(len(fft_list)):
@@ -267,15 +346,66 @@ def void_freq(song_name, offset, songlen, increment, minfreq, maxfreq, upperthr,
 
     print("Done")
 
-if(True):
+def get_tpts(data, sample_rate, thr):
-    void_freq("worlds_end_3.wav", 74.582, 84.582, 10.001, minfreq=0, maxfreq=440, upperthr=4500, ampthr=60)
+    res = []
-    #void_freq("440.wav", 0, 3.9, 3.901, minfreq=0, maxfreq=0, upperthr=20000)
+    for i in range(len(data)):
+        if(data[i] > thr):
+            res.append(i/sample_rate)
+    
+    for i in res:
+        print(i)
+    return res
+
+def test_sample(timelist):
+    for i in range(1,len(timelist)):
+        #os.system('play -n synth %s sin %s' % (0.05, 440))
+        for k in range(random.randint(1, 10)):
+            print("E", end="")
+        print("F")
+        sleep(timelist[i]-timelist[i-1])
+
+#Offset = 74.582
+#BPM = 178
+#Length = 48*60/BPM-0.01
+
+#Offset = 0
+#BPM = 180
+#Length = 48*60/BPM-0.01
+
+#Offset = 7
+#BPM = 140
+#Length = 32*60/BPM-0.01
+
+Offset = 0
+BPM = 160
+Length = 30*60/BPM-0.01
+DivLen = 60/BPM-0.01
+N_iter = 48
+
+print("Total length :", np.round(DivLen*N_iter, 3), "s")
+
+subprocess.run(["sleep", "1"]) 
 
 if(True):
+    #void_freq("tetris_4.wav", Offset, Offset+Length, 4*60/BPM, minfreq=0, maxfreq=330, upperthr=5000, ampthr=60, ampfreq = 1200, ampval = 7.27, leniency = 0.005, write=True)
+    void_freq("tetris_4.wav", Offset, Offset+DivLen*(N_iter+1)+0.01, 4*60/BPM, minfreq=0, maxfreq=330, upperthr=5000, ampthr=60, ampfreq = 1200, ampval = 7.27, leniency = 0.005, write=True)
+
+if(False):  
     #data2 = filter_n_percent("worlds_end_3.wav", 74.582, 15, 0.2, reduce=False, show=True)
-    data2 = filter_n_percent("trimmed.wav", 0, 10, 0.1, reduce=False, show=False)
+    data2 = filter_n_percent("trimmed.wav", 0, Length, 0.5, reduce=False, show=False)
-    data2 = snap(data2, 44100, 180, 4, show=True)
+    #data2 = filter_n_percent("tetris_3.wav", 7, Length, 0.01, reduce=False, show=False)
-    #write_to_file_thr(1000, data2, 74.582, 0.02, "timing_points.csv")
+    data2 = snap(data2, 44100, BPM, 4, show=True)
+
+    #timing_pts = get_tpts(data2, 1000, 1000)
+    #test_sample(timing_pts)
+
+    write_to_file_thr(1000, data2, Offset, 0.02, "timing_points.csv")
+
+if(True):
+    datares = filter_n_percent_serial("trimmed.wav", Offset, N_iter, DivLen, 0.5)
+    datares = snap(datares, 44100, BPM, 4, show=True)
+    freqs = get_freq("trimmed.wav", Offset, DivLen, DivLen*N_iter, datares)
+
 
 print("Program finished with return 0")