Update app.py

app.py

@@ -136,47 +136,111 @@ def render_midi_output(final_composition):
 def load_midi(input_midi):
     """Process the input MIDI file and create a token sequence using without velocity logic."""
     raw_score = TMIDIX.midi2single_track_ms_score(input_midi.name)
-    escore_notes = TMIDIX.advanced_score_processor(
-        raw_score, return_enhanced_score_notes=True, apply_sustain=True
-    )[0]
-    sp_escore_notes = TMIDIX.solo_piano_escore_notes(escore_notes)
-    zscore = TMIDIX.recalculate_score_timings(sp_escore_notes)
-    zscore = TMIDIX.augment_enhanced_score_notes(zscore, timings_divider=32)
-    fscore = TMIDIX.fix_escore_notes_durations(zscore)
-    cscore = TMIDIX.chordify_score([1000, fscore])
     
-    score = []
-    prev_chord = cscore[0]
-    for chord in cscore:
-        # Time difference token.
-        score.append(max(0, min(127, chord[0][1] - prev_chord[0][1])))
-        for note in chord:
-            score.extend([
-                max(1, min(127, note[2])) + 128,
-                max(1, min(127, note[4])) + 256
-            ])
-        prev_chord = chord
-    return score
+    escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True, apply_sustain=True)
+    
+    escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes[0], sort_drums_last=True)
+    
+    dscore = TMIDIX.delta_score_notes(escore_notes)
+    
+    dcscore = TMIDIX.chordify_score([d[1:] for d in dscore])
+    
+    melody_chords = [18816]
+    
+    #=======================================================
+    # MAIN PROCESSING CYCLE
+    #=======================================================
+    
+    for i, c in enumerate(dcscore):
+    
+        delta_time = c[0][0]
+    
+        melody_chords.append(delta_time)
+    
+        for e in c:
+        
+            #=======================================================
+            
+            # Durations
+            dur = max(1, min(255, e[1]))
+    
+            # Patches
+            pat = max(0, min(128, e[5]))
+            
+            # Pitches
+            ptc = max(1, min(127, e[3]))
+            
+            # Velocities
+            # Calculating octo-velocity
+            vel = max(8, min(127, e[4]))
+            velocity = round(vel / 15)-1
+            
+            #=======================================================
+            # FINAL NOTE SEQ
+            #=======================================================
+            
+            # Writing final note
+            pat_ptc = (128 * pat) + ptc 
+            dur_vel = (8 * dur) + velocity
+    
+            melody_chords.extend([pat_ptc+256, dur_vel+16768])
+        
+    return melody_chords
 
 def save_midi(tokens, batch_number=None):
     """Convert token sequence back to a MIDI score and write it using TMIDIX (without velocity).
        The output MIDI file name incorporates a date-time stamp.
     """
-    song_events = []
-    time_marker = 0
-    duration = 0
-    pitch = 0
-    patches = [0] * 16
-
-    for token in tokens:
-        if 0 <= token < 128:
-            time_marker += token * 32
-        elif 128 <= token < 256:
-            duration = (token - 128) * 32
-        elif 256 <= token < 384:
-            pitch = token - 256
-            song_events.append(['note', time_marker, duration, 0, pitch, max(40, pitch), 0])
-        # No velocity tokens are used.
+    time = 0
+    dur = 1
+    vel = 90
+    pitch = 60
+    channel = 0
+    patch = 0
+
+    patches = [-1] * 16
+
+    channels = [0] * 16
+    channels[9] = 1
+
+    for ss in tokens:
+
+        if 0 <= ss < 256:
+
+            time += ss * 16
+
+        if 256 <= ss < 16768:
+
+            patch = (ss-256) // 128
+
+            if patch < 128:
+
+                if patch not in patches:
+                  if 0 in channels:
+                      cha = channels.index(0)
+                      channels[cha] = 1
+                  else:
+                      cha = 15
+
+                  patches[cha] = patch
+                  channel = patches.index(patch)
+                else:
+                  channel = patches.index(patch)
+
+            if patch == 128:
+                channel = 9
+
+            pitch = (ss-256) % 128
+
+
+        if 16768 <= ss < 18816:
+
+            dur = ((ss-16768) // 8) * 16
+            vel = (((ss-16768) % 8)+1) * 15
+
+            song_f.append(['note', time, dur, channel, pitch, vel ])
+
+    patches = [0 if x==-1 else x for x in patches]
     
     # Generate a time stamp using the PDT timezone.
     timestamp = datetime.datetime.now(PDT).strftime("%Y%m%d_%H%M%S")
@@ -186,17 +250,17 @@ def save_midi(tokens, batch_number=None):
     else:
         fname = f"Orpheus-Music-Transformer-Music-Composition_{timestamp}_Batch_{batch_number}"'''
 
-    fname = f"Orpheus-Music-Transformer-Music-Composition"
+    fname = f"Orpheus-Music-Transformer-Composition"
     
     TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(
-        song_events,
+        song_f,
         output_signature='Orpheus Music Transformer',
         output_file_name=fname,
         track_name='Project Los Angeles',
         list_of_MIDI_patches=patches,
         verbose=False
     )
-    return fname, song_events
+    return fname, song_f
 
 # -----------------------------
 # MUSIC GENERATION FUNCTION (Combined)
@@ -204,7 +268,7 @@ def save_midi(tokens, batch_number=None):
 @spaces.GPU
 def generate_music(prime, num_gen_tokens, num_mem_tokens, num_gen_batches, model_temperature):
     """Generate music tokens given prime tokens and parameters."""
-    inputs = prime[-num_mem_tokens:] if prime else [0]
+    inputs = prime[-num_mem_tokens:] if prime else [18816]
     print("Generating...")
     inp = torch.LongTensor([inputs] * num_gen_batches).cuda()
     with ctx:
@@ -258,7 +322,7 @@ def generate_music_and_state(input_midi, num_prime_tokens, num_gen_tokens, num_m
         plot_kwargs = {'plot_title': f'Batch # {i}', 'return_plt': True}
         
         if len(final_composition) > PREVIEW_LENGTH:
-            plot_kwargs['preview_length_in_notes'] = len([t for t in preview_tokens if t > 256])
+            plot_kwargs['preview_length_in_notes'] = len([t for t in preview_tokens if 256 <= t < 16768])
 
         midi_plot = TMIDIX.plot_ms_SONG(midi_score, **plot_kwargs)
         midi_audio = midi_to_colab_audio(midi_fname + '.mid',
@@ -391,9 +455,9 @@ with gr.Blocks() as demo:
                       [final_composition, generated_batches, block_lines])
 
     gr.Markdown("## Generate")
-    num_prime_tokens = gr.Slider(15, 3072, value=3072, step=1, label="Number of prime tokens")
-    num_gen_tokens = gr.Slider(15, 1024, value=512, step=1, label="Number of tokens to generate")
-    num_mem_tokens = gr.Slider(15, 4096, value=4096, step=1, label="Number of memory tokens")
+    num_prime_tokens = gr.Slider(16, 7168, value=7168, step=1, label="Number of prime tokens")
+    num_gen_tokens = gr.Slider(16, 1024, value=512, step=1, label="Number of tokens to generate")
+    num_mem_tokens = gr.Slider(16, 8192, value=8192, step=1, label="Number of memory tokens")
     model_temperature = gr.Slider(0.1, 1, value=0.9, step=0.01, label="Model temperature")
     generate_btn = gr.Button("Generate", variant="primary")