Update app.py

app.py

@@ -14,6 +14,9 @@ import gradio as gr
 from x_transformer_1_23_2 import *
 import random
 
+import statistics
+import copy
+
 import tqdm
 
 from midi_to_colab_audio import midi_to_colab_audio
@@ -88,130 +91,201 @@ def GenerateAccompaniment(input_midi, input_num_tokens, input_conditioning_type,
     print('=' * 70)
 
     #===============================================================================
+    
     raw_score = TMIDIX.midi2single_track_ms_score(input_midi.name)
     
-    #===============================================================================
-    # Enhanced score notes
+    escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)
     
-    escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
+    if escore_notes:
+        
+        escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes[0], timings_divider=32, legacy_timings=True)
     
-    no_drums_escore_notes = [e for e in escore_notes if e[6] < 80]
+        if escore_notes:
     
-    if len(no_drums_escore_notes) > 0:
+            #=======================================================
+            # PRE-PROCESSING
     
-        #=======================================================
-        # PRE-PROCESSING
-        
-        #===============================================================================
-        # Augmented enhanced score notes
-        
-        no_drums_escore_notes = TMIDIX.augment_enhanced_score_notes(no_drums_escore_notes)
-        
-        cscore = TMIDIX.chordify_score([1000, no_drums_escore_notes])
-        
-        clean_cscore = []
-        
-        for c in cscore:
-            pitches = []
-            cho = []
-            for cc in c:
-                if cc[4] not in pitches:
-                    cho.append(cc)
-                    pitches.append(cc[4])
-        
-            clean_cscore.append(cho)
-        
-        #=======================================================
-        # FINAL PROCESSING
-        
-        melody_chords = []
-        chords = []
-        times = [0]
-        durs = []
-        
-        #=======================================================
-        # MAIN PROCESSING CYCLE
-        #=======================================================
-        
-        pe = clean_cscore[0][0]
-        
-        first_chord = True
-        
-        for c in clean_cscore:
-        
-            # Chords
-        
-            c.sort(key=lambda x: x[4], reverse=True)
-        
-            tones_chord = sorted(set([cc[4] % 12 for cc in c]))
-        
-            try:
-                chord_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord)
-            except:
-                checked_tones_chord = TMIDIX.check_and_fix_tones_chord(tones_chord)
-                chord_token = TMIDIX.ALL_CHORDS_SORTED.index(checked_tones_chord)
-        
-            melody_chords.extend([chord_token+384])
-        
-            if input_strip_notes:
-              if len(tones_chord) > 1:
-                chords.extend([chord_token+384])
-        
-            else:
-              chords.extend([chord_token+384])
-        
-            if first_chord:
-                    melody_chords.extend([0])
-                    first_chord = False
-        
-            for e in c:
-        
+            # checking number of instruments in a composition
+            instruments_list = sorted(set([e[6] for e in escore_notes]))
+            instruments_list_without_drums = sorted(set([e[6] for e in escore_notes if e[3] != 9]))
+            main_instruments_list = sorted(set([e[6] for e in escore_notes if e[6] < 80]))
+            
+            comp_times = [e[1] for e in escore_notes if e[6] < 80]
+                
+            comp_dtimes = [max(1, min(127, b-a)) for a, b in zip(comp_times[:-1], comp_times[1:]) if b-a != 0]
+            avg_comp_dtime = max(0, min(127, int(sum(comp_dtimes) / len(comp_dtimes))))
+            
                 #=======================================================
-                # Timings...
-        
-                time = e[1]-pe[1]
-        
-                dur = e[2]
-        
-                if time != 0 and time % 2 != 0:
-                    time += 1
-                if dur % 2 != 0:
-                    dur += 1
-        
-                delta_time = int(max(0, min(255, time)) / 2)
-        
-                # Durations
-        
-                dur = int(max(0, min(255, dur)) / 2)
-        
-                # Pitches
-        
-                ptc = max(1, min(127, e[4]))
-        
+                # FINAL PROCESSING
+    
                 #=======================================================
-                # FINAL NOTE SEQ
-        
-                # Writing final note asynchronously
-        
-                if delta_time != 0:
-                    melody_chords.extend([delta_time, dur+128, ptc+256])
-                    if input_strip_notes:
-                      if len(c) > 1:
-                        times.append(delta_time)
-                        durs.append(dur+128)
-                    else:
-                        times.append(delta_time)
-                        durs.append(dur+128)
+                # Adjusting avg velocity
+    
+                vels = [e[5] for e in escore_notes]
+                avg_vel = int(sum(vels) / len(vels))
+    
+                if avg_vel < 60:
+                    TMIDIX.adjust_score_velocities(escore_notes, avg_vel * 2)
+    
+                melody_chords = []
+                melody_chords2 = []
+                mel_cho = []
+    
+                #=======================================================
+                # Break between compositions / Intro seq
+    
+                if 128 in instruments_list:
+                    drums_present = 1931 # Yes
                 else:
-                    melody_chords.extend([dur+128, ptc+256])
-        
-                pe = e
+                    drums_present = 1930 # No
+    
+                melody_chords.extend([1929, drums_present])
+                mel_cho.extend([1929, drums_present])
+    
+                #=======================================================
+                # Composition patches list
+    
+                melody_chords.extend([i+1932 for i in instruments_list_without_drums])
+                mel_cho.extend([i+1932 for i in instruments_list_without_drums])
+                #=======================================================
+                # Composition avg pitch and dtime
+    
+                mode_instruments_pitch = statistics.mode([e[4] for e in escore_notes if e[6] < 80])
+    
+                melody_chords.extend([2060+mode_instruments_pitch, 2188+avg_comp_dtime])
+                mel_cho.extend([2060+mode_instruments_pitch, 2188+avg_comp_dtime])
+    
+                melody_chords2.append(mel_cho)
+    
+                #=======================================================
+                # MAIN PROCESSING CYCLE
+                #=======================================================
+    
+                cscore = TMIDIX.chordify_score([1000, escore_notes])
+    
+                pc = cscore[0] # Previous chord
+    
+                for i, c in enumerate(cscore):
+    
+                    c.sort(key=lambda x: x[6]) # Sorting by patch
+    
+                    #=======================================================
+                    # Outro seq
+    
+                    #if len(cscore) > 256:
+                    #    if len(cscore) - i == 64:
+                    #        melody_chords.extend([2236])
+    
+                    #=======================================================
+                    # Timings...
+    
+                    # Cliping all values...
+                    delta_time = max(0, min(127, c[0][1]-pc[0][1]))
+    
+                    #=======================================================
+                    # Chords...
+    
+                    cpitches = sorted([e[4] for e in c if e[3] != 9])
+                    dpitches = [e[4] for e in c if e[3] == 9]
+    
+                    tones_chord = sorted(set([p % 12 for p in cpitches]))
+    
+                    if tones_chord:
+    
+                        if tones_chord not in TMIDIX.ALL_CHORDS_SORTED:
+                            tones_chord_tok = 644
+                            tones_chord_tok = TMIDIX.ALL_CHORDS_SORTED.index(TMIDIX.advanced_check_and_fix_tones_chord(tones_chord, cpitches[-1]))
+    
+                        else:
+                            tones_chord_tok = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord) # 321
+    
+                        if dpitches:
+    
+                            if tones_chord_tok == 644:
+                                tones_chord_tok = 645
+                            else:
+                                tones_chord_tok += 321
+    
+                    else:
+                        tones_chord_tok = 643 # Drums-only chord
+    
+                    #=======================================================
+                    # Writing chord/time...
+    
+                    melody_chords.extend([tones_chord_tok, delta_time+646])
+                    
+                    mel_cho = []
+                    mel_cho.extend([tones_chord_tok, delta_time+646])
+    
+                    #=======================================================
+                    # Notes...
+    
+                    pp = -1
+    
+                    for e in c:
+    
+                        #=======================================================
+                        # Duration
+                        dur = max(0, min(63, int(max(0, e[2] // 4) * 2)))
+    
+                        # Pitch
+                        ptc = max(1, min(127, e[4]))
+    
+                        # Octo-velocity
+                        vel = max(8, min(127, (max(1, e[5] // 8) * 8)))
+                        velocity = round(vel / 15)-1
+    
+                        # Patch
+                        pat = max(0, min(128, e[6]))
+                        
+                        if 7 < pat < 80:
+                            ptc += 128
+    
+                        elif 79 < pat < 128:
+                            ptc += 256
+    
+                        elif pat == 128:
+                            ptc += 384
+    
+                        #=======================================================
+                        # FINAL NOTE SEQ
+    
+                        # Writing final note asynchronously
+    
+                        dur_vel = (8 * dur) + velocity # 512
+    
+                        if pat != pp:
+                            melody_chords.extend([pat+774, ptc+904, dur_vel+1416]) # 1928
+                            mel_cho.extend([pat+774, ptc+904, dur_vel+1416])
+    
+                        else:
+                            melody_chords.extend([ptc+904, dur_vel+1416])
+                            mel_cho.extend([ptc+904, dur_vel+1416])
+    
+                        pp = pat
+    
+                    pc = c
+    
+                    melody_chords2.append(mel_cho)
+    
+                    #=======================================================
+    
+                #melody_chords.extend([2237]) # EOS
+    
+                #=======================================================
+                # TOTAL DICTIONARY SIZE 2237+1=2238
+                #=======================================================
+    
+    print('Done!')
+    print('=' * 70)
+    print(len(melody_chords))
+    print('=' * 70)
         
     #==================================================================
 
     print('=' * 70)
     
-    print('Sample output events', melody_chords[:5])
+    print('Sample output events', melody_chords[:12])
     print('=' * 70)
     print('Generating...')
 
@@ -291,34 +365,50 @@ def GenerateAccompaniment(input_midi, input_num_tokens, input_conditioning_type,
         channel = 0
         
         patches = [0] * 16
-        
-        channel = 0
-        
+        patches[9] = 9
+    
         for ss in song:
-        
-          if 0 <= ss < 128:
-        
-              time += ss * 32
-        
-          if 128 <= ss < 256:
-        
-              dur = (ss-128) * 32
-        
-          if 256 <= ss < 384:
-        
-              pitch = (ss-256)
-        
-              vel = max(40, pitch)
-        
-              song_f.append(['note', time, dur, channel, pitch, vel, 0])
+    
+            if 645 < ss < 774:
+    
+                time += (ss-646)
+                
+            if 773 < ss < 904:
+                
+                pat = (ss - 774)
+                     
+                chan = (pat // 8)
+                
+                if 0 <= chan < 9:
+                    channel = chan
+                
+                elif 8 < chan < 15:
+                    channel = chan + 1
+    
+                elif chan == 16:
+                    channel = 9
+    
+            if 903 < ss < 1416:
+    
+                pitch = (ss-904) % 128
+    
+            if 1415 < ss < 1928:
+    
+                dur = (((ss-1416) // 8)+1) * 2
+                vel = (((ss-1416) % 8)+1) * 15
+                
+                song_f.append(['note', time, dur, channel, pitch, vel, pat])
+    
+    song_f, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(song_f)
 
-    fn1 = "Chords-Progressions-Transformer-Composition"
+    fn1 = "Ultimate-Chords-Progressions-Transformer-Composition"
     
     detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,
-                                                              output_signature = 'Chords Progressions Transformer',
+                                                              output_signature = 'Ultimate Chords Progressions Transformer',
                                                               output_file_name = fn1,
                                                               track_name='Project Los Angeles',
-                                                              list_of_MIDI_patches=patches
+                                                              list_of_MIDI_patches=patches,
+                                                              timings_multiplier=32
                                                               )
     
     new_fn = fn1+'.mid'
@@ -341,7 +431,7 @@ def GenerateAccompaniment(input_midi, input_num_tokens, input_conditioning_type,
     output_midi = str(new_fn)
     output_audio = (16000, audio)
     
-    output_plot = TMIDIX.plot_ms_SONG(song_f, plot_title=output_midi, return_plt=True)
+    output_plot = TMIDIX.plot_ms_SONG(song_f, plot_title=output_midi, return_plt=True, timings_multiplier=32)
 
     print('Output MIDI file name:', output_midi)
     print('Output MIDI title:', output_midi_title)