Update app.py

app.py

@@ -85,109 +85,119 @@ def GenerateAccompaniment(input_midi, input_num_tokens, input_conditioning_type)
     
     escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
     
-    escore_notes = [e for e in escore_notes if e[3] != 9]
+    no_drums_escore_notes = [e for e in escore_notes if e[6] < 80]
     
-    if len(escore_notes) > 0:
+    if len(no_drums_escore_notes) > 0:
     
-      #=======================================================
-      # PRE-PROCESSING
-    
-      #===============================================================================
-      # Augmented enhanced score notes
-    
-      escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes, timings_divider=32)
-    
-      cscore = TMIDIX.chordify_score([1000, escore_notes])
-    
-      melody = TMIDIX.fix_monophonic_score_durations([sorted(e, key=lambda x: x[4], reverse=True)[0] for e in cscore])
-    
-      #=======================================================
-      # FINAL PROCESSING
-    
-      melody_chords = []
-    
-      #=======================================================
-      # MAIN PROCESSING CYCLE
-      #=======================================================
-    
-      pe = cscore[0][0]
-    
-      mpe = melody[0]
-    
-      midx = 1
-    
-      for i, c in enumerate(cscore):
-    
-          c.sort(key=lambda x: (x[3], x[4]), reverse=True)
-    
-          # Next melody note
-    
-          if midx < len(melody):
-    
-            # Time
-            mtime = melody[midx][1]-mpe[1]
-    
-            mdur = melody[midx][2]
-    
-            mdelta_time = max(0, min(127, mtime))
-    
-            # Durations
-            mdur = max(0, min(127, mdur))
-    
-            # Pitch
-            mptc = melody[midx][4]
-    
-          else:
-            mtime = 127-mpe[1]
-    
-            mdur = mpe[2]
-    
-            mdelta_time = max(0, min(127, mtime))
-    
-            # Durations
-            mdur = max(0, min(127, mdur))
-    
-            # Pitch
-            mptc = mpe[4]
-    
-    
-          e = melody[i]
-    
-          #=======================================================
-          # Timings...
-    
-          time = e[1]-pe[1]
-    
-          dur = e[2]
-    
-          delta_time = max(0, min(127, time))
-    
-          # Durations
-    
-          dur = max(0, min(127, dur))
-    
-          # Pitches
-    
-          ptc = max(1, min(127, e[4]))
-    
-          if ptc < 60:
-            ptc = 60 + (ptc % 12)
-    
-          cha = e[3]
-    
-          #=======================================================
-          # FINAL NOTE SEQ
-    
-          if midx < len(melody):
-            melody_chords.append([delta_time, dur+128, ptc+384, mdelta_time+512, mptc+640])
-            mpe = melody[midx]
-            midx += 1
-          else:
-            melody_chords.append([delta_time, dur+128, ptc+384, mdelta_time+512, mptc+640])
-    
-          pe = e
-
-    #===============================================================================
+        #=======================================================
+        # 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 strip_notes_from_composition:
+              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:
+        
+                #=======================================================
+                # 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 NOTE SEQ
+        
+                # Writing final note asynchronously
+        
+                if delta_time != 0:
+                    melody_chords.extend([delta_time, dur+128, ptc+256])
+                    if strip_notes_from_composition:
+                      if len(c) > 1:
+                        times.append(delta_time)
+                        durs.append(dur+128)
+                    else:
+                        times.append(delta_time)
+                        durs.append(dur+128)
+                else:
+                    melody_chords.extend([dur+128, ptc+256])
+        
+                pe = e
+        
+    #==================================================================
 
     print('=' * 70)
     
@@ -269,50 +279,37 @@ def GenerateAccompaniment(input_midi, input_num_tokens, input_conditioning_type)
         song_f = []
     
         time = 0
-        ntime = 0
-        ndur = 0
+        dur = 0
         vel = 90
-        npitch = 0
+        pitch = 0
         channel = 0
-    
+        
         patches = [0] * 16
-        patches[0] = accompaniment_MIDI_patch_number
-        patches[3] = melody_MIDI_patch_number
-    
-        for i, ss in enumerate(song):
-    
-                ntime += melody_chords[i][0] * 32
-                ndur = (melody_chords[i][1]-128) * 32
-                nchannel = 1
-                npitch = (melody_chords[i][2]-256) % 128
-                vel = max(40, npitch)+20
-    
-                song_f.append(['note', ntime, ndur, 3, npitch, vel, melody_MIDI_patch_number ])
-    
-                time = ntime
-    
-                for s in ss:
-    
-                  if 0 <= s < 128:
-    
-                      time += s * 32
-    
-                  if 128 <= s < 256:
-    
-                      dur = (s-128) * 32
-    
-                  if 256 <= s < 384:
-    
-                      pitch = (s-256)
-    
-                      vel = max(40, pitch)
-    
-                      song_f.append(['note', time, dur, 0, pitch, vel, accompaniment_MIDI_patch_number])
+        
+        channel = 0
+        
+        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])
 
-    fn1 = "Ultimate-Accompaniment-Transformer-Composition"
+    fn1 = "Chords-Progressions-Transformer-Composition"
     
     detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,
-                                                              output_signature = 'Ultimate Accompaniment Transformer',
+                                                              output_signature = 'Chords Progressions Transformer',
                                                               output_file_name = fn1,
                                                               track_name='Project Los Angeles',
                                                               list_of_MIDI_patches=patches