Update app.py

app.py

@@ -129,7 +129,48 @@ def kmp_search(main_list, sublist):
 
 #==================================================================================
 
-def Remix_MIDI(max_num_loops,
+def load_midi(midi_file):
+
+    print('Loading MIDI...')
+
+    raw_score = TMIDIX.midi2single_track_ms_score(midi_file)
+    escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
+    escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes, sort_drums_last=True)
+    
+    zscore = TMIDIX.recalculate_score_timings(escore_notes)
+    
+    cscore = TMIDIX.chordify_score([1000, zscore])
+    
+    tones_chords = []
+    tones_chords_idxs = []
+    
+    for i, c in enumerate(cscore):
+        pitches = [e[4] for e in c if e[3] != 9]
+    
+        if pitches:
+            tones_chord = sorted(set([p % 12 for p in pitches]))
+                 
+            if tones_chord in TMIDIX.ALL_CHORDS_SORTED:
+                chord_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord)
+                
+            else:
+                tones_chord = TMIDIX.check_and_fix_tones_chord(tones_chord)
+                chord_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord)
+        
+            tones_chords.append(chord_token)
+            tones_chords_idxs.append(i)
+    
+    print('Done!')
+    print('=' * 70)
+    print('MIDI has', len(tones_chords), 'chords')
+    print('=' * 70)
+
+    return tones_chords, tones_chords_idxs
+
+#==================================================================================
+
+def Remix_MIDI(input_midi,
+               max_num_loops,
                comp_loops_mult,
                chords_chunks_len,
                loops_chords_set_len
@@ -142,8 +183,13 @@ def Remix_MIDI(max_num_loops,
     start_time = reqtime.time()
     print('=' * 70)
     
+    fn = os.path.basename(input_midi)
+    fn1 = fn.split('.')[0]
+
+    print('=' * 70)
     print('Requested settings:')
     print('=' * 70)
+    print('Input MIDI file name:', fn)
     print('Max number of loops:', max_num_loops)
     print('Num of loops reps:', comp_loops_mult)
     print('Matches chords chunks len:', chords_chunks_len)
@@ -153,24 +199,20 @@ def Remix_MIDI(max_num_loops,
 
     #===============================================================================
 
-    print('Prepping dataset...')
-
-    chunk_len = chords_chunks_len
-    chunk_chords_set = loops_chords_set_len
+    tones_chords, tones_chords_idxs = load_midi(input_midi.name)
     
-    all_chords_chunks = []
+    #===============================================================================
     
-    midi_loops = [l for l in midi_loops_dataset if len(set(l[1])) >= chunk_chords_set]
+    print('Prepping chords chunks...')
+
+    chunk_len = 4
     
-    for loop in tqdm.tqdm(midi_loops):
-        
-        fn = loop[0]
-        chords = loop[1]
-        score = loop[2]
-        
-        all_chords_chunks.append(chords[:chunk_len])
+    all_chords_chunks = Counter()
     
-    all_chords_chunks = np.array(all_chords_chunks)
+    for i in range(0, len(tones_chords)):
+        chunk = tones_chords[i:i+chunk_len]
+        if len(chunk) == chunk_len:
+            all_chords_chunks[tuple(chunk)] += 1
 
     print('Done!')
     print('=' * 70)
@@ -179,106 +221,65 @@ def Remix_MIDI(max_num_loops,
 
     #==================================================================
     
-    print('Mixing loops...')
+    print('Remixing MIDI...')
     print('=' * 70)
 
-    max_tries = 100
-    loops_mult = 1
-    
-    song_loops_counter = 0
+    other_chunks = [list(k) for k, v in all_chords_chunks.most_common(10)]
+
+    all_match_chunks = {}
+
+    for mc_chunk in other_chunks:
+        chunk_lens = fuzzy_find([len(l) for l in split_by_sublist(tones_chords, mc_chunk) if len(l) > chunk_len])
+        match_chunks = [l for l in split_by_sublist(tones_chords, mc_chunk) if len(l) in chunk_lens]
+        all_match_chunks[tuple(mc_chunk)] = match_chunks
+
+    chunks_map = random.choices(other_chunks, k=10)
+
+    #==================================================================
+
+    matched_chunks = []
+    start_chunk = []
+    res = -1
+    tries = 0
+    while  res == -1 and len(start_chunk[:res]) < chunk_len and tries < 100:
     
-    stries = 0
+        start_chunk = random.choice(all_match_chunks[tuple(chunks_map[0])])
+        res = kmp_search(start_chunk, chunks_map[1])[0]
     
-    while song_loops_counter < max_num_loops:
+        tries += 1
     
-        if stries % 25 == 0:
-            print('Mixing attempt #', stries)
-            
-        stries += 1
+        #print(res)
+    if tries < 100:
+        matched_chunks.append(start_chunk[:res])
     
-        midxs = []
-        sidxs = [-1]
-        
-        while not midxs:
-        
-            song_names = []
-            song_chords = []
-            song_scores = []
-            song_idxs = []
-            sidx = -1
-    
-            while sidx in sidxs:
-                sidx = random.randint(0, len(midi_loops)-1)
-                
-            song_idxs.append(sidx)
-            sidxs.append(sidx)
-            
-            song_names.append(midi_loops[sidx][0])
-            song_chords.append(midi_loops[sidx][1][-chunk_len:]) #tv
-            song_scores.append(midi_loops[sidx][2])
-            
-            song_midxs = [(song_idxs[-1]*loops_mult)+3]
-        
-            midxs = [song_midxs[-1]]
-        
-            midxs = find_matches(np.array(song_chords[-1]), all_chords_chunks)
-            midxs = [midx for midx in midxs if midx != song_midxs[-1]]
-        
-        song_loops_counter = 1
-        rtries = 0
-        end = False
-        
-        while song_loops_counter < max_num_loops and not end:
-        
-            midxs = [song_midxs[-1]]
-            midxs = []
-            rmidxs = [-1]
-        
-            midxs = find_matches(np.array(song_chords[-1]), all_chords_chunks)
-            midxs = [midx for midx in midxs if midx != song_midxs[-1]]
-        
-            if midxs:
-                midx = find_best_midx(midi_loops, midxs, song_midxs[-1])
-        
-            else:
-                midx = rmidxs[-1]
-        
-            if midx not in rmidxs and midx not in song_midxs:    
-            
-                song_midxs.append(midx)
+    else:
+        print('FAIL!')
 
-                sidx = int(midx // loops_mult)
-                song_idxs.append(sidx)
-            
-                song = midi_loops[sidx]    
-                
-                song_names.append(song[0])
-                song_chords.append(song[1][-chunk_len:]) # tv
-                song_scores.append(song[2])    
-        
-                song_loops_counter += 1
+    #==================================================================
+
+    mchunks = [-1]
+    tries = 0
+    while -1 in mchunks and tries < 100:
+    
+        mchunks = []
         
-            else:
-                if len(rmidxs) > 1 and rtries < max_tries:
-                    song_idxs.pop()
-                    song_midxs.pop()
-                    song_names.pop()
-                    song_chords.pop()
-                    song_scores.pop()
-                    song_loops_counter -= 1
-                    rtries += 1
-                    rmidxs.append(midx)
+        for i, chunk in enumerate(chunks_map[1:-1]):
+            start_chunk = random.choice(all_match_chunks[tuple(chunk)])
+            res = kmp_search(start_chunk, chunks_map[i+2])[0]
         
-                else:
-                    end = True
-                    break
+            #print(res)
+            mchunks.append(start_chunk[:res])
     
-            if end:
-                break
-                
-        if stries > 1000:
-            break
-            
+        tries += 1
+    
+    if tries < 100:
+        matched_chunks.extend(mchunks)
+    
+    else:
+        print('FAIL!')
+
+    #==================================================================
+
     print('=' * 70)
     print('Done!')
     print('=' * 70)
@@ -287,105 +288,41 @@ def Remix_MIDI(max_num_loops,
 
     print('Creating final MIDI score...')
 
-    loops_mult = comp_loops_mult
+    all_matches_dscores = []
 
-    final_song = []
-    
-    last_max_dur = 0
-    last_dtime = 0
-    mode_dtime = 0
-    mode_dur = 0
+    for match in matched_chunks:
     
-    for i, src_score in enumerate(song_scores):
-    
-        final_song.append(['text_event', 0, song_names[i]])
-    
-        score = copy.deepcopy(src_score)
-    
-        for j in range(loops_mult):
-    
-            if j == loops_mult-1 and not (i == len(song_scores)-1 and j == loops_mult-1):
+        start, end = kmp_search(tones_chords, match)
+        
+        sidx = tones_chords_idxs[start]
+        eidx = tones_chords_idxs[end]
     
-                if i > 0:
-                    last_chord = score[[e for e in range(len(score)) if score[e][0] > 0][-1]:]
-                    last_dtime = last_chord[0][0]
-                    last_max_dur = max([e[1] for e in last_chord])
-                
-                    dtimes = [e[0] for e in score if e[0] != 0]
-                    durs = [e[1] for e in score]
-                    
-                    mode_dtime= statistics.mode(dtimes)
-                    mode_dur = statistics.mode(durs)
-                        
-                score[0][0] = max(mode_dtime, mode_dur)
-            
-                rscore = list(reversed(score))
-            
-                ccount = 0
-                
-                for r in range(len(rscore)):
-                    if rscore[r][0] > 0:
-                        ccount += 1
-                
-                    if ccount == chunk_len:
-                        break
-                        
-                trimmed_score = score[:-(r+1)]
+        all_matches_dscores.append(TMIDIX.delta_score_notes(TMIDIX.flatten(cscore[sidx:eidx+1])))
+
+    #===============================================================================
     
-                extended_score = [['note'] + e for e in trimmed_score]
+    new_dscore = all_matches_dscores[0]
     
-                final_song.extend(extended_score)
-                
+    for score in all_matches_dscores[1:]:
+        score[0][1] = statistics.mode([e[1] for e in new_dscore[-75:] if e[1] != 0 and e[3] != 9])
+        new_dscore.extend(score)
     
-            else:
-                if i > 0:
-                    last_chord = score[[e for e in range(len(score)) if score[e][0] > 0][-1]:]
-                    last_dtime = last_chord[0][0]
-                    last_max_dur = max([e[1] for e in last_chord])
-                    
-                    dtimes = [e[0] for e in score if e[0] != 0]
-                    durs = [e[1] for e in score]
-                    
-                    mode_dtime= statistics.mode(dtimes)
-                    mode_dur = statistics.mode(durs)
-                        
-                score[0][0] = max(mode_dtime, mode_dur)
+    new_escore = TMIDIX.delta_score_to_abs_score(new_dscore)
         
-                extended_score = [['note'] + e for e in score]
-    
-                final_song.extend(extended_score)
-
-    final_song_abs = TMIDIX.delta_score_to_abs_score(final_song)
+    #===============================================================================
 
     print('Done!')
     print('=' * 70)
 
-    #===============================================================================
-
-    print('Creating MIDI summary...')
-
-    midi_summary = 'Number of source MIDI loops: ' + str(len(song_names) * loops_mult) + '\n'
-    midi_summary += '-' * 40
-    midi_summary += '\n'
-
-    for i, song_name in enumerate(song_names):
-
-        son_art = song_name.split('___')[:2]
-
-        son = son_art[0]
-        art = son_art[1]
-
-        midi_summary += 'Loops # ' + str((i*loops_mult)+1) + '-' + str((i*loops_mult)+loops_mult) + ': "' + son + '" by ' + art + '\n'          
-            
-    #===============================================================================
+    #===============================================================================    
     
     print('Rendering results...')
     
     print('=' * 70)
-    print('Sample MIDI events:', final_song_abs[:3])
+    print('Sample MIDI events:', new_escore[:3])
     print('=' * 70)
 
-    output_score, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(final_song_abs)
+    output_score, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(new_escore)
 
     fn1 = "MIDI-Remixer-Composition"
     
@@ -412,7 +349,6 @@ def Remix_MIDI(max_num_loops,
 
     #========================================================
 
-    output_midi_summary = str(midi_summary)
     output_midi = str(new_fn)
     output_audio = (16000, audio)
     
@@ -424,10 +360,6 @@ def Remix_MIDI(max_num_loops,
 
     print('Output MIDI file name:', output_midi)
     print('=' * 70)
-    print('Output MIDI summary:')
-    print('-' * 70)
-    print(output_midi_summary)
-    print('=' * 70) 
     
     #========================================================
     
@@ -436,7 +368,7 @@ def Remix_MIDI(max_num_loops,
     print('-' * 70)
     print('Req execution time:', (reqtime.time() - start_time), 'sec')
 
-    return output_midi_summary, output_audio, output_plot, output_midi
+    return output_audio, output_plot, output_midi
     
 #==================================================================================
 
@@ -475,25 +407,22 @@ with gr.Blocks() as demo:
     chords_chunks_len = gr.Slider(6, 10, value=6, step=1, label="Number of loops chords to match")
     loops_chords_set_len = gr.Slider(16, 24, value=16, step=1, label="Minimum number of unique chords in each loop")
     
-    mix_btn = gr.Button("Mix", variant="primary")
+    mix_btn = gr.Button("Remix", variant="primary")
 
     gr.Markdown("## Mixing results")
 
-    output_midi_summary = gr.Textbox(label="MIDI summary")
     output_audio = gr.Audio(label="MIDI audio", format="wav", elem_id="midi_audio")
     output_plot = gr.Plot(label="MIDI score plot")
     output_midi = gr.File(label="MIDI file", file_types=[".mid"])
 
     mix_btn.click(Remix_MIDI, 
-                   [
+                   [input_midi,
                     max_num_loops,
                     comp_loops_mult,
                     chords_chunks_len,
                     loops_chords_set_len
                    ], 
-                   [
-                    output_midi_summary,
-                    output_audio,
+                   [output_audio,
                     output_plot,
                     output_midi                          
                    ]