Update app.py

app.py

@@ -5,6 +5,7 @@ import rtmidi
 import MIDI
 import base64
 import io
+import os
 from huggingface_hub import hf_hub_download
 from midi_synthesizer import MidiSynthesizer
 
@@ -14,25 +15,44 @@ class MIDIManager:
     def __init__(self):
         self.soundfont_path = hf_hub_download(repo_id="skytnt/midi-model", filename="soundfont.sf2")
         self.synthesizer = MidiSynthesizer(self.soundfont_path)
-        self.loaded_midi = {}  # Store uploaded MIDI files
-        self.modified_files = []  # Track generated files
+        self.loaded_midi = {}  # Key: midi_id, Value: (file_path, midi_data)
+        self.modified_files = []
         self.is_playing = False
         self.midi_in = rtmidi.MidiIn()
         self.midi_in.open_port(0) if self.midi_in.get_ports() else None
         self.midi_in.set_callback(self.midi_callback)
         self.live_notes = []
+        self.example_files = self.load_example_midis()
+
+    def load_example_midis(self):
+        # Check for MIDI files in a local 'examples' directory or predefined paths
+        example_dir = "examples"  # Adjust this path as needed
+        examples = {}
+        if os.path.exists(example_dir):
+            for file in os.listdir(example_dir):
+                if file.endswith(".mid") or file.endswith(".midi"):
+                    midi_id = f"example_{len(examples)}"
+                    file_path = os.path.join(example_dir, file)
+                    examples[midi_id] = (file_path, MIDI.load(file_path))
+        # Add a default example if none found
+        if not examples:
+            midi = MIDI.MIDIFile(1)
+            midi.addTrack()
+            midi.addNote(0, 0, 60, 0, 100, 100)  # C4 note
+            examples["example_0"] = ("Simple C4.mid", midi)
+        return examples
 
     def midi_callback(self, event, data=None):
         message, _ = event
         if len(message) >= 3 and message[0] & 0xF0 == 0x90:  # Note On
             note, velocity = message[1], message[2]
             if velocity > 0:
-                self.live_notes.append((note, velocity, 0))  # Time placeholder
+                self.live_notes.append((note, velocity, 0))
 
     def load_midi(self, file_path):
         midi = MIDI.load(file_path)
-        midi_id = f"midi_{len(self.loaded_midi)}"
-        self.loaded_midi[midi_id] = midi
+        midi_id = f"midi_{len(self.loaded_midi) - len(self.example_files)}"
+        self.loaded_midi[midi_id] = (file_path, midi)
         return midi_id
 
     def extract_notes(self, midi):
@@ -46,7 +66,8 @@ class MIDIManager:
     def generate_variation(self, midi_id, length_factor=2, variation=0.3):
         if midi_id not in self.loaded_midi:
             return None
-        notes = self.extract_notes(self.loaded_midi[midi_id])
+        _, midi = self.loaded_midi[midi_id]
+        notes = self.extract_notes(midi)
         new_notes = []
         for _ in range(int(length_factor)):
             for note, vel, time in notes:
@@ -100,12 +121,12 @@ class MIDIManager:
         time_cum = 0
         for note, vel, _ in self.live_notes:
             midi.addNote(0, 0, note, time_cum, 100, vel)
-            time_cum += 100  # Simple timing
+            time_cum += 100
         output = io.BytesIO()
         midi.writeFile(output)
         midi_data = base64.b64encode(output.getvalue()).decode('utf-8')
         self.modified_files.append(midi_data)
-        self.live_notes = []  # Reset after saving
+        self.live_notes = []
         return midi_data
 
 midi_manager = MIDIManager()
@@ -117,6 +138,9 @@ def create_download_list():
     html += "</ul>"
     return html
 
+def get_midi_choices():
+    return [(os.path.basename(path), midi_id) for midi_id, (path, _) in midi_manager.loaded_midi.items()]
+
 with gr.Blocks(theme=gr.themes.Soft()) as app:
     gr.Markdown("<h1>🎵 MIDI Composer 🎵</h1>")
     
@@ -126,34 +150,39 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
             midi_files = gr.File(label="Upload MIDI Files", file_count="multiple")
             midi_list = gr.State({})
             file_display = gr.HTML(value="No files loaded")
+            output = gr.Audio(label="Generated Preview", type="bytes", autoplay=True)
             
-            def load_files(files):
-                midi_list_val = {}
+            def load_and_generate(files):
+                midi_list_val = midi_manager.loaded_midi.copy()
                 html = "<h3>Loaded Files</h3>"
+                midi_data = None
                 for file in files or []:
                     midi_id = midi_manager.load_midi(file.name)
-                    midi_list_val[midi_id] = file.name
+                    midi_list_val[midi_id] = (file.name, midi_manager.loaded_midi[midi_id][1])
                     html += f"<div>{file.name}</div>"
-                return midi_list_val, html
+                    midi_data = midi_manager.generate_variation(midi_id)
+                return (midi_list_val, html, 
+                        io.BytesIO(base64.b64decode(midi_data)) if midi_data else None, 
+                        get_midi_choices())
             
-            midi_files.change(load_files, inputs=[midi_files], outputs=[midi_list, file_display])
+            midi_files.change(load_and_generate, inputs=[midi_files], 
+                            outputs=[midi_list, file_display, output, gr.State(get_midi_choices())])
 
         # Tab 2: Generate & Perform
         with gr.Tab("Generate & Perform"):
-            midi_select = gr.Dropdown(label="Select MIDI", choices=[])
+            midi_select = gr.Dropdown(label="Select MIDI", choices=get_midi_choices(), value=None)
             length_factor = gr.Slider(1, 5, value=2, step=1, label="Length Factor")
             variation = gr.Slider(0, 1, value=0.3, label="Variation")
             generate_btn = gr.Button("Generate")
             effect = gr.Radio(["tempo"], label="Effect", value="tempo")
             intensity = gr.Slider(0, 1, value=0.5, label="Intensity")
             apply_btn = gr.Button("Apply Effect")
-            play_btn = gr.Button("Play Loop")
-            stop_btn = gr.Button("Stop")
-            output = gr.Audio(label="Preview", type="bytes")
+            stop_btn = gr.Button("Stop Playback")
+            output = gr.Audio(label="Preview", type="bytes", autoplay=True)
             status = gr.Textbox(label="Status", value="Ready")
             
             def update_dropdown(midi_list):
-                return gr.update(choices=list(midi_list.keys()))
+                return gr.update(choices=get_midi_choices())
             
             midi_list.change(update_dropdown, inputs=[midi_list], outputs=[midi_select])
             
@@ -161,30 +190,34 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
                 if not midi_id:
                     return None, "Select a MIDI file"
                 midi_data = midi_manager.generate_variation(midi_id, length, var)
-                return io.BytesIO(base64.b64decode(midi_data)), "Generated"
+                midi_manager.play_with_loop(midi_data)
+                return io.BytesIO(base64.b64decode(midi_data)), "Playing"
             
             def apply_effect(midi_data, fx, inten):
                 if not midi_data:
                     return None, "Generate a MIDI first"
                 new_data = midi_manager.apply_synth_effect(midi_data.decode('utf-8'), fx, inten)
-                return io.BytesIO(base64.b64decode(new_data)), "Effect Applied"
+                midi_manager.play_with_loop(new_data)
+                return io.BytesIO(base64.b64decode(new_data)), "Playing"
             
             generate_btn.click(generate, inputs=[midi_select, length_factor, variation], 
                               outputs=[output, status])
             apply_btn.click(apply_effect, inputs=[output, effect, intensity], 
                            outputs=[output, status])
-            play_btn.click(midi_manager.play_with_loop, inputs=[output], outputs=[status])
             stop_btn.click(midi_manager.stop_playback, inputs=None, outputs=[status])
 
         # Tab 3: MIDI Input
         with gr.Tab("MIDI Input"):
             gr.Markdown("Play your MIDI keyboard to record notes")
             save_btn = gr.Button("Save Live MIDI")
-            live_output = gr.Audio(label="Live MIDI", type="bytes")
+            live_output = gr.Audio(label="Live MIDI", type="bytes", autoplay=True)
             
             def save_live():
                 midi_data = midi_manager.save_live_midi()
-                return io.BytesIO(base64.b64decode(midi_data)) if midi_data else None
+                if midi_data:
+                    midi_manager.play_with_loop(midi_data)
+                    return io.BytesIO(base64.b64decode(midi_data))
+                return None
             
             save_btn.click(save_live, inputs=None, outputs=[live_output])
 
@@ -193,7 +226,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
             downloads = gr.HTML(value="No files yet")
             def update_downloads(*args):
                 return create_download_list()
-            gr.on(triggers=[generate_btn.click, apply_btn.click, save_btn.click], 
+            gr.on(triggers=[midi_files.change, generate_btn.click, apply_btn.click, save_btn.click], 
                   fn=update_downloads, inputs=None, outputs=[downloads])
 
     gr.Markdown("""