Update app.py

app.py

@@ -5,6 +5,7 @@ import glob
 import json
 import os
 import time
+import rtmidi
 from concurrent.futures import ThreadPoolExecutor
 
 import gradio as gr
@@ -23,89 +24,128 @@ in_space = os.getenv("SYSTEM") == "spaces"
 
 # Chord to emoji mapping
 CHORD_EMOJIS = {
-    'A': '🎸', 
-    'Am': '🎻',
-    'B': '🎹',
-    'Bm': '🎷',
-    'C': '🎵',
-    'Cm': '🎶',
-    'D': '🥁',
-    'Dm': '🪘',
-    'E': '🎤',
-    'Em': '🎧',
-    'F': '🪕',
-    'Fm': '🎺',
-    'G': '🪗',
-    'Gm': '🎻'
+    'C': '🎵', 'Cm': '🎶', 'C7': '🎼', 'Cmaj7': '🎹', 'Cm7': '🎻',
+    'D': '🥁', 'Dm': '🪘', 'D7': '🎷', 'Dmaj7': '🎺', 'Dm7': '🪕',
+    'E': '🎸', 'Em': '🎻', 'E7': '🎵', 'Emaj7': '🎶', 'Em7': '🎼',
+    'F': '🎹', 'Fm': '🎸', 'F7': '🎻', 'Fmaj7': '🎷', 'Fm7': '🎺',
+    'G': '🪗', 'Gm': '🎵', 'G7': '🎶', 'Gmaj7': '🎼', 'Gm7': '🎹',
+    'A': '🎸', 'Am': '🎻', 'A7': '🎷', 'Amaj7': '🎺', 'Am7': '🪕',
+    'B': '🎵', 'Bm': '🎶', 'B7': '🎼', 'Bmaj7': '🎹', 'Bm7': '🎻'
 }
 
-# Progression patterns
-PROGRESSION_PATTERNS = {
-    "12-bar-blues": ["I", "I", "I", "I", "IV", "IV", "I", "I", "V", "IV", "I", "V"],
-    "pop-verse": ["I", "V", "vi", "IV"],
-    "pop-chorus": ["I", "IV", "V", "vi"],
-    "jazz": ["ii", "V", "I"],
-    "ballad": ["I", "vi", "IV", "V"]
-}
-
-# Roman numeral to chord offset mapping (in major scale)
-ROMAN_TO_OFFSET = {
-    "I": 0,
-    "ii": 2,
-    "iii": 4,
-    "IV": 5,
-    "V": 7,
-    "vi": 9,
-    "vii": 11
+# Chord note definitions (MIDI note numbers)
+CHORD_NOTES = {
+    'C': [60, 64, 67],     # C major (C, E, G)
+    'Cm': [60, 63, 67],    # C minor (C, Eb, G)
+    'C7': [60, 64, 67, 70], # C7 (C, E, G, Bb)
+    'Cmaj7': [60, 64, 67, 71], # Cmaj7 (C, E, G, B)
+    'Cm7': [60, 63, 67, 70], # Cm7 (C, Eb, G, Bb)
+    
+    'D': [62, 66, 69],     # D major (D, F#, A)
+    'Dm': [62, 65, 69],    # D minor (D, F, A)
+    'D7': [62, 66, 69, 72], # D7 (D, F#, A, C)
+    'Dmaj7': [62, 66, 69, 73], # Dmaj7 (D, F#, A, C#)
+    'Dm7': [62, 65, 69, 72], # Dm7 (D, F, A, C)
+    
+    'E': [64, 68, 71],     # E major (E, G#, B)
+    'Em': [64, 67, 71],    # E minor (E, G, B)
+    'E7': [64, 68, 71, 74], # E7 (E, G#, B, D)
+    'Emaj7': [64, 68, 71, 75], # Emaj7 (E, G#, B, D#)
+    'Em7': [64, 67, 71, 74], # Em7 (E, G, B, D)
+    
+    'F': [65, 69, 72],     # F major (F, A, C)
+    'Fm': [65, 68, 72],    # F minor (F, Ab, C)
+    'F7': [65, 69, 72, 75], # F7 (F, A, C, Eb)
+    'Fmaj7': [65, 69, 72, 76], # Fmaj7 (F, A, C, E)
+    'Fm7': [65, 68, 72, 75], # Fm7 (F, Ab, C, Eb)
+    
+    'G': [67, 71, 74],     # G major (G, B, D)
+    'Gm': [67, 70, 74],    # G minor (G, Bb, D)
+    'G7': [67, 71, 74, 77], # G7 (G, B, D, F)
+    'Gmaj7': [67, 71, 74, 78], # Gmaj7 (G, B, D, F#)
+    'Gm7': [67, 70, 74, 77], # Gm7 (G, Bb, D, F)
+    
+    'A': [69, 73, 76],     # A major (A, C#, E)
+    'Am': [69, 72, 76],    # A minor (A, C, E)
+    'A7': [69, 73, 76, 79], # A7 (A, C#, E, G)
+    'Amaj7': [69, 73, 76, 80], # Amaj7 (A, C#, E, G#)
+    'Am7': [69, 72, 76, 79], # Am7 (A, C, E, G)
+    
+    'B': [71, 75, 78],     # B major (B, D#, F#)
+    'Bm': [71, 74, 78],    # B minor (B, D, F#)
+    'B7': [71, 75, 78, 81], # B7 (B, D#, F#, A)
+    'Bmaj7': [71, 75, 78, 82], # Bmaj7 (B, D#, F#, A#)
+    'Bm7': [71, 74, 78, 81]  # Bm7 (B, D, F#, A)
 }
 
-@torch.inference_mode()
-def generate(model: MIDIModel, prompt=None, batch_size=1, max_len=512, temp=1.0, top_p=0.98, top_k=20,
-             disable_patch_change=False, disable_control_change=False, disable_channels=None, generator=None):
-    tokenizer = model.tokenizer
-    if disable_channels is not None:
-        disable_channels = [tokenizer.parameter_ids["channel"][c] for c in disable_channels]
-    else:
-        disable_channels = []
-    max_token_seq = tokenizer.max_token_seq
-    if prompt is None:
-        input_tensor = torch.full((1, max_token_seq), tokenizer.pad_id, dtype=torch.long, device=model.device)
-        input_tensor[0, 0] = tokenizer.bos_id  # bos
-        input_tensor = input_tensor.unsqueeze(0)
-        input_tensor = torch.cat([input_tensor] * batch_size, dim=0)
-    else:
-        if len(prompt.shape) == 2:
-            prompt = prompt[None, :]
-            prompt = np.repeat(prompt, repeats=batch_size, axis=0)
-        elif prompt.shape[0] == 1:
-            prompt = np.repeat(prompt, repeats=batch_size, axis=0)
-        elif len(prompt.shape) != 3 or prompt.shape[0] != batch_size:
-            raise ValueError(f"invalid shape for prompt, {prompt.shape}")
-        prompt = prompt[..., :max_token_seq]
-        if prompt.shape[-1] < max_token_seq:
-            prompt = np.pad(prompt, ((0, 0), (0, 0), (0, max_token_seq - prompt.shape[-1])),
-                            mode="constant", constant_values=tokenizer.pad_id)
-        input_tensor = torch.from_numpy(prompt).to(dtype=torch.long, device=model.device)
-    
-    # Basic generation logic - simplified for brevity
-    # In a real implementation, you'd keep more of the original generation code
-    tokens_generated = []
-    cur_len = input_tensor.shape[1]
-    while cur_len < max_len:
-        # Generate next token sequence
-        with torch.no_grad():
-            # This is simplified - actual implementation would use the model logic
-            next_token_seq = torch.ones((batch_size, 1, max_token_seq), dtype=torch.long, device=model.device)
+# MIDI device manager
+class MIDIDeviceManager:
+    def __init__(self):
+        self.midi_out = rtmidi.MidiOut()
+        self.available_ports = self.midi_out.get_ports()
+        self.current_port = None
         
-        tokens_generated.append(next_token_seq)
-        input_tensor = torch.cat([input_tensor, next_token_seq[:, 0].unsqueeze(1)], dim=1)
-        cur_len += 1
-        
-        yield next_token_seq[:, 0].cpu().numpy()
-        
-        # Exit condition (simplified)
-        if cur_len >= max_len:
-            break
+    def get_available_devices(self):
+        """Return list of available MIDI output devices"""
+        self.available_ports = self.midi_out.get_ports()
+        return self.available_ports
+    
+    def open_port(self, port_index):
+        """Open a MIDI port by index"""
+        if 0 <= port_index < len(self.available_ports):
+            if self.current_port is not None:
+                self.midi_out.close_port()
+            self.midi_out.open_port(port_index)
+            self.current_port = port_index
+            return True
+        return False
+    
+    def send_note_on(self, note, velocity=64, channel=0):
+        """Send MIDI note on message"""
+        if self.current_port is not None:
+            message = [0x90 + channel, note, velocity]
+            self.midi_out.send_message(message)
+    
+    def send_note_off(self, note, velocity=0, channel=0):
+        """Send MIDI note off message"""
+        if self.current_port is not None:
+            message = [0x80 + channel, note, velocity]
+            self.midi_out.send_message(message)
+    
+    def send_program_change(self, program, channel=0):
+        """Send MIDI program change message"""
+        if self.current_port is not None:
+            message = [0xC0 + channel, program]
+            self.midi_out.send_message(message)
+    
+    def play_chord(self, chord_name, velocity=80, channel=0, duration=None):
+        """Play a chord by name with optional automatic release"""
+        if chord_name in CHORD_NOTES:
+            notes = CHORD_NOTES[chord_name]
+            for note in notes:
+                self.send_note_on(note, velocity, channel)
+            
+            if duration is not None:
+                # Automatic note off after duration
+                time.sleep(duration)
+                for note in notes:
+                    self.send_note_off(note, 0, channel)
+    
+    def release_chord(self, chord_name, channel=0):
+        """Release all notes in a chord"""
+        if chord_name in CHORD_NOTES:
+            notes = CHORD_NOTES[chord_name]
+            for note in notes:
+                self.send_note_off(note, 0, channel)
+    
+    def close(self):
+        """Close current MIDI port"""
+        if self.current_port is not None:
+            self.midi_out.close_port()
+            self.current_port = None
+
+# Global MIDI manager
+midi_manager = MIDIDeviceManager()
 
 def create_msg(name, data):
     return {"name": name, "data": data}
@@ -113,170 +153,67 @@ def create_msg(name, data):
 def send_msgs(msgs):
     return json.dumps(msgs)
 
-def get_chord_progressions(root_chord, progression_type):
-    """Convert a roman numeral progression to actual chords starting from root"""
-    major_scale = ["C", "D", "E", "F", "G", "A", "B"]
-    minor_scale = ["Cm", "Dm", "Em", "Fm", "Gm", "Am", "Bm"]
-    
-    # Find root index in major scale
-    root_idx = 0
-    for i, chord in enumerate(major_scale):
-        if chord == root_chord:
-            root_idx = i
-            break
-    
-    # Get progression pattern
-    pattern = PROGRESSION_PATTERNS.get(progression_type, PROGRESSION_PATTERNS["pop-verse"])
-    
-    # Generate actual chord progression
-    progression = []
-    for numeral in pattern:
-        is_minor = numeral.islower()
-        # Remove m if present in the numeral
-        base_numeral = numeral.replace("m", "")
-        # Get offset
-        offset = ROMAN_TO_OFFSET.get(base_numeral, 0)
-        
-        # Calculate actual chord index
-        chord_idx = (root_idx + offset) % 7
-        
-        # Add chord to progression
-        if is_minor:
-            progression.append(minor_scale[chord_idx])
-        else:
-            progression.append(major_scale[chord_idx])
-    
-    return progression
-
 def create_chord_events(chord, duration=480, velocity=80):
     """Create MIDI events for a chord"""
     events = []
-    chord_notes = {
-        'C': [60, 64, 67],  # C major (C, E, G)
-        'Cm': [60, 63, 67], # C minor (C, Eb, G)
-        'D': [62, 66, 69],  # D major (D, F#, A)
-        'Dm': [62, 65, 69], # D minor (D, F, A)
-        'E': [64, 68, 71],  # E major (E, G#, B)
-        'Em': [64, 67, 71], # E minor (E, G, B)
-        'F': [65, 69, 72],  # F major (F, A, C)
-        'Fm': [65, 68, 72], # F minor (F, Ab, C)
-        'G': [67, 71, 74],  # G major (G, B, D)
-        'Gm': [67, 70, 74], # G minor (G, Bb, D)
-        'A': [69, 73, 76],  # A major (A, C#, E)
-        'Am': [69, 72, 76], # A minor (A, C, E)
-        'B': [71, 75, 78],  # B major (B, D#, F#)
-        'Bm': [71, 74, 78]  # B minor (B, D, F#)
-    }
     
-    if chord in chord_notes:
-        notes = chord_notes[chord]
+    if chord in CHORD_NOTES:
+        notes = CHORD_NOTES[chord]
         # Note on events
         for note in notes:
             events.append(['note_on', 0, 0, 0, 0, note, velocity])
         
-        # Note off events
+        # Note off events after specified duration
         for note in notes:
             events.append(['note_off', duration, 0, 0, 0, note, 0])
     
     return events
 
-def create_chord_sequence(tokenizer, chords, pattern="simple", duration=480):
-    """Create a sequence of chord events with a pattern"""
-    events = []
-    
-    for chord in chords:
-        if pattern == "simple":
-            # Just play the chord
-            events.extend(create_chord_events(chord, duration))
-        elif pattern == "arpeggio":
-            # Arpeggiate the chord
-            chord_notes = {
-                'C': [60, 64, 67],
-                'Cm': [60, 63, 67],
-                'D': [62, 66, 69],
-                'Dm': [62, 65, 69],
-                'E': [64, 68, 71],
-                'Em': [64, 67, 71],
-                'F': [65, 69, 72],
-                'Fm': [65, 68, 72],
-                'G': [67, 71, 74],
-                'Gm': [67, 70, 74],
-                'A': [69, 73, 76],
-                'Am': [69, 72, 76],
-                'B': [71, 75, 78],
-                'Bm': [71, 74, 78]
-            }
-            
-            if chord in chord_notes:
-                notes = chord_notes[chord]
-                for i, note in enumerate(notes):
-                    events.append(['note_on', 0 if i == 0 else duration//4, 0, 0, 0, note, 80])
-                    events.append(['note_off', duration//4, 0, 0, 0, note, 0])
-                
-                # Add final pause to complete the bar
-                events.append(['note_on', 0, 0, 0, 0, notes[0], 0])
-                events.append(['note_off', duration//4, 0, 0, 0, notes[0], 0])
-    
-    # Convert events to tokens
-    tokens = []
-    for event in events:
-        tokens.append(tokenizer.event2tokens(event))
-    
-    return tokens
+def add_chord_to_queue(chord_name, chord_queue, max_queue_size=8):
+    """Add a chord to the playback queue"""
+    if len(chord_queue) >= max_queue_size:
+        chord_queue.pop(0)  # Remove oldest chord
+    chord_queue.append(chord_name)
+    return chord_queue
 
-def add_chord_sequence(model_name, mid_seq, root_chord="C", progression_type="pop-verse", pattern="simple"):
-    """Add a chord sequence to the MIDI sequence"""
-    tokenizer = models[model_name].tokenizer
-    
-    # Generate chord progression
-    chord_progression = create_chord_progressions(root_chord, progression_type)
-    
-    # Create chord sequence tokens
-    tokens = create_chord_sequence(tokenizer, chord_progression, pattern)
-    
-    # Add tokens to sequence
-    if mid_seq is None:
-        mid_seq = [[tokenizer.bos_id] + [tokenizer.pad_id] * (tokenizer.max_token_seq - 1)]
-        mid_seq = [mid_seq] * OUTPUT_BATCH_SIZE
-    
-    # Add tokens to the first sequence
-    mid_seq[0].extend(tokens)
-    
-    return mid_seq
+def play_chord_on_device(chord_name, midi_device_index):
+    """Play a chord on the selected MIDI device"""
+    if midi_device_index is not None and midi_device_index >= 0:
+        midi_manager.open_port(midi_device_index)
+        midi_manager.play_chord(chord_name, duration=0.5)
+    return chord_name
 
-def create_song_structure(model_name, root_chord="C"):
-    """Create a complete song structure with verse, chorus, etc."""
-    tokenizer = models[model_name].tokenizer
-    
-    # Initialize sequence
-    mid_seq = [[tokenizer.bos_id] + [tokenizer.pad_id] * (tokenizer.max_token_seq - 1)]
-    mid_seq = [mid_seq] * OUTPUT_BATCH_SIZE
-    
-    # Add intro
-    intro_tokens = create_chord_sequence(tokenizer, 
-                                        create_chord_progressions(root_chord, "pop-verse"), 
-                                        "arpeggio")
-    mid_seq[0].extend(intro_tokens)
-    
-    # Add verse
-    verse_tokens = create_chord_sequence(tokenizer, 
-                                         create_chord_progressions(root_chord, "pop-verse"),
-                                         "simple")
-    mid_seq[0].extend(verse_tokens)
-    
-    # Add chorus
-    chorus_tokens = create_chord_sequence(tokenizer, 
-                                          create_chord_progressions(root_chord, "pop-chorus"),
-                                          "simple")
-    mid_seq[0].extend(chorus_tokens)
-    
-    # Add outro
-    outro_tokens = create_chord_sequence(tokenizer, 
-                                         create_chord_progressions(root_chord, "ballad"),
-                                         "arpeggio")
-    mid_seq[0].extend(outro_tokens)
+def play_chord_sequence(chord_queue, midi_device_index, tempo=120):
+    """Play a sequence of chords at the specified tempo"""
+    if midi_device_index is not None and midi_device_index >= 0:
+        # Calculate timing based on tempo (beats per minute)
+        beat_duration = 60.0 / tempo  # seconds per beat
+        
+        midi_manager.open_port(midi_device_index)
+        
+        for chord in chord_queue:
+            midi_manager.play_chord(chord, duration=beat_duration)
+            # Add a small gap between chords
+            time.sleep(0.05)
     
-    return mid_seq
+    return chord_queue
+
+def refresh_midi_devices():
+    """Refresh the list of available MIDI devices"""
+    return gr.Dropdown.update(choices=midi_manager.get_available_devices())
+
+def hf_hub_download_retry(repo_id, filename):
+    print(f"downloading {repo_id} {filename}")
+    retry = 0
+    err = None
+    while retry < 30:
+        try:
+            return hf_hub_download(repo_id=repo_id, filename=filename)
+        except Exception as e:
+            err = e
+            retry += 1
+    if err:
+        raise err
 
 def load_javascript(dir="javascript"):
     scripts_list = glob.glob(f"{dir}/*.js")
@@ -298,27 +235,19 @@ def load_javascript(dir="javascript"):
 
     gr.routes.templates.TemplateResponse = template_response
 
-def render_audio(model_name, mid_seq, should_render_audio):
-    if (not should_render_audio) or mid_seq is None:
-        outputs = [None] * OUTPUT_BATCH_SIZE
-        return tuple(outputs)
-    tokenizer = models[model_name].tokenizer
-    outputs = []
-    if not os.path.exists("outputs"):
-        os.mkdir("outputs")
-    audio_futures = []
-    for i in range(OUTPUT_BATCH_SIZE):
-        mid = tokenizer.detokenize(mid_seq[i])
-        audio_future = thread_pool.submit(synthesis_task, mid)
-        audio_futures.append(audio_future)
-    for future in audio_futures:
-        outputs.append((44100, future.result()))
-    if OUTPUT_BATCH_SIZE == 1:
-        return outputs[0]
-    return tuple(outputs)
-
-def synthesis_task(mid):
-    return synthesizer.synthesis(MIDI.score2opus(mid))
+def create_virtual_keyboard(chord_types):
+    """Create virtual keyboard buttons organized by root note and chord type"""
+    root_notes = ['C', 'D', 'E', 'F', 'G', 'A', 'B']
+    buttons = {}
+    
+    for root in root_notes:
+        buttons[root] = {}
+        for chord_type in chord_types:
+            chord_name = f"{root}{chord_type}"
+            emoji = CHORD_EMOJIS.get(chord_name, "🎵")
+            buttons[root][chord_type] = (chord_name, emoji)
+    
+    return buttons
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
@@ -330,29 +259,56 @@ if __name__ == "__main__":
     opt = parser.parse_args()
     OUTPUT_BATCH_SIZE = opt.batch
     
+    # Initialize MIDI device manager
+    midi_manager = MIDIDeviceManager()
+    
     # Initialize models (simplified version)
     soundfont_path = hf_hub_download_retry(repo_id="skytnt/midi-model", filename="soundfont.sf2")
     thread_pool = ThreadPoolExecutor(max_workers=OUTPUT_BATCH_SIZE)
     synthesizer = MidiSynthesizer(soundfont_path)
     
-    models_info = {
-        "generic pretrain model (tv2o-medium) by skytnt": [
-            "skytnt/midi-model-tv2o-medium", {}
-        ]
-    }
+    # Define chord types to use in the virtual keyboard
+    chord_types = ['', 'm', '7', 'maj7', 'm7']
+    
+    # Create virtual keyboard structure
+    keyboard = create_virtual_keyboard(chord_types)
     
-    models = {}
-    # Initialize models (simplified)
-    for name, (repo_id, loras) in models_info.items():
-        model = MIDIModel.from_pretrained(repo_id)
-        model.to(device="cpu", dtype=torch.float32)
-        models[name] = model
+    # Define CSS for the virtual keyboard
+    keyboard_css = """
+    .chord-button {
+        margin: 4px;
+        min-width: 80px;
+        height: 60px;
+        font-size: 18px;
+        font-weight: bold;
+        border-radius: 8px;
+        transition: all 0.2s;
+    }
+    .chord-button:active {
+        transform: scale(0.95);
+    }
+    .chord-queue {
+        padding: 10px;
+        background: #f5f5f5;
+        border-radius: 8px;
+        min-height: 50px;
+        font-size: 16px;
+        margin-bottom: 15px;
+    }
+    .root-c { background-color: #FFCDD2; }
+    .root-d { background-color: #F8BBD0; }
+    .root-e { background-color: #E1BEE7; }
+    .root-f { background-color: #D1C4E9; }
+    .root-g { background-color: #C5CAE9; }
+    .root-a { background-color: #BBDEFB; }
+    .root-b { background-color: #B3E5FC; }
+    """
     
     load_javascript()
-    app = gr.Blocks(theme=gr.themes.Soft())
+    app = gr.Blocks(theme=gr.themes.Soft(), css=keyboard_css)
     
     with app:
-        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>🎵 Chord-Emoji MIDI Composer 🎵</h1>")
+        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>🎵 Real-Time MIDI Chord Keyboard 🎵</h1>")
         
         js_msg = gr.Textbox(elem_id="msg_receiver", visible=False)
         js_msg.change(None, [js_msg], [], js="""
@@ -363,183 +319,117 @@ if __name__ == "__main__":
         }
         """)
         
-        input_model = gr.Dropdown(label="Select Model", choices=list(models.keys()),
-                                  type="value", value=list(models.keys())[0])
-        
-        # Main chord progression section
-        with gr.Tabs():
-            with gr.TabItem("Chord Progressions") as tab1:
-                with gr.Row():
-                    root_chord = gr.Dropdown(label="Root Chord", choices=["C", "D", "E", "F", "G", "A", "B"], 
-                                           value="C")
-                    progression_type = gr.Dropdown(label="Progression Type", 
-                                                 choices=list(PROGRESSION_PATTERNS.keys()),
-                                                 value="pop-verse")
-                
-                # Emoji-Chord Button Grid - Create a 2x7 grid of chord buttons
-                gr.Markdown("### Chord Buttons - Click to Add Individual Chords")
-                
-                with gr.Row():
-                    chord_buttons_major = []
-                    for chord in ["C", "D", "E", "F", "G", "A", "B"]:
-                        emoji = CHORD_EMOJIS.get(chord, "🎵")
-                        btn = gr.Button(f"{emoji} {chord}", size="sm")
-                        chord_buttons_major.append((chord, btn))
-                
-                with gr.Row():
-                    chord_buttons_minor = []
-                    for chord in ["Cm", "Dm", "Em", "Fm", "Gm", "Am", "Bm"]:
-                        emoji = CHORD_EMOJIS.get(chord, "🎵")
-                        btn = gr.Button(f"{emoji} {chord}", size="sm")
-                        chord_buttons_minor.append((chord, btn))
-                
-                # Song structure buttons
-                gr.Markdown("### Song Structure Patterns - Click to Add a Pattern")
-                with gr.Row():
-                    intro_btn = gr.Button("🎵 Intro", variant="primary")
-                    verse_btn = gr.Button("🎸 Verse", variant="primary")
-                    chorus_btn = gr.Button("🎹 Chorus", variant="primary")
-                    bridge_btn = gr.Button("🎷 Bridge", variant="primary")
-                    outro_btn = gr.Button("🪗 Outro", variant="primary")
-                
-                with gr.Row():
-                    blues_btn = gr.Button("🎺 12-Bar Blues", variant="primary")
-                    jazz_btn = gr.Button("🎻 Jazz Pattern", variant="primary")
-                    ballad_btn = gr.Button("🎤 Ballad", variant="primary")
-                    
-                with gr.Row():
-                    pattern_type = gr.Radio(label="Pattern Style", 
-                                          choices=["simple", "arpeggio"], 
-                                          value="simple")
-                
-                with gr.Row():
-                    clear_btn = gr.Button("🗑️ Clear Sequence", variant="secondary")
-                    play_btn = gr.Button("▶️ Play Current Sequence", variant="primary")
-                
-            with gr.TabItem("Custom MIDI Settings") as tab2:
-                input_instruments = gr.Dropdown(label="🪗 Instruments (auto if empty)", 
-                                             choices=["Acoustic Grand", "Electric Piano", "Violin", "Guitar"],
-                                             multiselect=True, type="value")
-                input_bpm = gr.Slider(label="BPM (beats per minute)", minimum=60, maximum=180,
-                                    step=1, value=120)
-        
-        # Output section
-        output_midi_seq = gr.State()
-        output_continuation_state = gr.State([0])
-        
-        midi_outputs = []
-        audio_outputs = []
-        
-        with gr.Tabs(elem_id="output_tabs"):
-            for i in range(OUTPUT_BATCH_SIZE):
-                with gr.TabItem(f"Output {i + 1}") as tab:
-                    output_midi_visualizer = gr.HTML(elem_id=f"midi_visualizer_container_{i}")
-                    output_audio = gr.Audio(label="Output Audio", format="mp3", elem_id=f"midi_audio_{i}")
-                    output_midi = gr.File(label="Output MIDI", file_types=[".mid"])
-                    midi_outputs.append(output_midi)
-                    audio_outputs.append(output_audio)
-        
-        # Connect chord buttons to functions
-        for chord, btn in chord_buttons_major + chord_buttons_minor:
-            btn.click(
-                fn=lambda chord=chord, m=input_model, seq=output_midi_seq, pt=pattern_type: 
-                   add_chord_sequence(m, seq, chord, "ballad", pt.value),
-                inputs=[input_model, output_midi_seq, pattern_type],
-                outputs=[output_midi_seq]
-            )
-        
-        # Connect song structure buttons
-        intro_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "pop-verse", "arpeggio"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
-        )
-        
-        verse_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "pop-verse", "simple"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
-        )
+        # MIDI Device Settings
+        with gr.Row():
+            with gr.Column(scale=3):
+                midi_device = gr.Dropdown(label="MIDI Output Device", 
+                                         choices=midi_manager.get_available_devices(),
+                                         type="index")
+                refresh_button = gr.Button("🔄 Refresh MIDI Devices")
+            
+            with gr.Column(scale=1):
+                tempo = gr.Slider(label="Tempo (BPM)", 
+                                 minimum=40, 
+                                 maximum=200, 
+                                 value=120, 
+                                 step=1)
         
-        chorus_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "pop-chorus", "simple"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
-        )
+        # Chord Queue Display
+        chord_queue = gr.State([])
+        queue_display = gr.Markdown("### Current Chord Queue\n*No chords in queue*", 
+                                   elem_classes=["chord-queue"])
         
-        bridge_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "jazz", "simple"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
-        )
+        # Play queue button
+        play_queue_button = gr.Button("▶️ Play Chord Sequence", variant="primary", size="lg")
         
-        outro_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "ballad", "arpeggio"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
-        )
+        # Clear queue button
+        clear_queue_button = gr.Button("🗑️ Clear Queue", variant="secondary")
         
-        blues_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "12-bar-blues", "simple"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
-        )
+        # Virtual Keyboard - Create sections for each root note
+        gr.Markdown("## Virtual Chord Keyboard")
         
-        jazz_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "jazz", "simple"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
-        )
+        for root in ['C', 'D', 'E', 'F', 'G', 'A', 'B']:
+            with gr.Row():
+                gr.Markdown(f"### {root}")
+                for chord_type in chord_types:
+                    chord_name, emoji = keyboard[root][chord_type]
+                    display_name = chord_name if chord_type == '' else chord_name
+                    button = gr.Button(f"{emoji} {display_name}", 
+                                      elem_classes=[f"chord-button root-{root.lower()}"])
+                    
+                    # Connect the button to add chord to queue and play it immediately
+                    button.click(
+                        fn=play_chord_on_device,
+                        inputs=[gr.State(chord_name), midi_device],
+                        outputs=None
+                    ).then(
+                        fn=add_chord_to_queue,
+                        inputs=[gr.State(chord_name), chord_queue],
+                        outputs=[chord_queue]
+                    ).then(
+                        fn=lambda q: f"### Current Chord Queue\n" + " → ".join(q) if q else "*No chords in queue*",
+                        inputs=[chord_queue],
+                        outputs=[queue_display]
+                    )
         
-        ballad_btn.click(
-            fn=lambda m=input_model, seq=output_midi_seq, rc=root_chord: 
-               add_chord_sequence(m, seq, rc.value, "ballad", "simple"),
-            inputs=[input_model, output_midi_seq, root_chord],
-            outputs=[output_midi_seq]
+        # Connect refresh button
+        refresh_button.click(
+            fn=refresh_midi_devices,
+            inputs=None,
+            outputs=[midi_device]
         )
         
-        # Clear and play buttons
-        clear_btn.click(
-            fn=lambda m=input_model: [[models[m].tokenizer.bos_id] + 
-                                     [models[m].tokenizer.pad_id] * (models[m].tokenizer.max_token_seq - 1)] * OUTPUT_BATCH_SIZE,
-            inputs=[input_model],
-            outputs=[output_midi_seq]
+        # Connect play queue button
+        play_queue_button.click(
+            fn=play_chord_sequence,
+            inputs=[chord_queue, midi_device, tempo],
+            outputs=[chord_queue]
         )
         
-        # Play functionality - render audio and visualize
-        def prepare_playback(model_name, mid_seq):
-            if mid_seq is None:
-                return mid_seq, [], send_msgs([])
-            
-            tokenizer = models[model_name].tokenizer
-            msgs = []
-            
-            for i in range(OUTPUT_BATCH_SIZE):
-                events = [tokenizer.tokens2event(tokens) for tokens in mid_seq[i]]
-                msgs += [
-                    create_msg("visualizer_clear", [i, tokenizer.version]),
-                    create_msg("visualizer_append", [i, events]),
-                    create_msg("visualizer_end", i)
-                ]
-            
-            return mid_seq, mid_seq, send_msgs(msgs)
-        
-        play_btn.click(
-            fn=prepare_playback,
-            inputs=[input_model, output_midi_seq],
-            outputs=[output_midi_seq, output_continuation_state, js_msg]
+        # Connect clear queue button
+        clear_queue_button.click(
+            fn=lambda: [],
+            inputs=None,
+            outputs=[chord_queue]
         ).then(
-            fn=render_audio,
-            inputs=[input_model, output_midi_seq, gr.State(True)],
-            outputs=audio_outputs
+            fn=lambda: "### Current Chord Queue\n*No chords in queue*",
+            inputs=None,
+            outputs=[queue_display]
         )
         
+        # MIDI Generation Settings (for advanced users)
+        with gr.Accordion("Advanced MIDI Settings", open=False):
+            with gr.Row():
+                midi_channel = gr.Slider(label="MIDI Channel", 
+                                        minimum=0, 
+                                        maximum=15, 
+                                        value=0, 
+                                        step=1)
+                
+                instrument = gr.Dropdown(label="Instrument", 
+                                       choices=[(f"{i}: {name}", i) for i, name in enumerate([
+                                           "Acoustic Grand Piano", "Bright Acoustic Piano", "Electric Grand Piano",
+                                           "Honky-tonk Piano", "Electric Piano 1", "Electric Piano 2", "Harpsichord",
+                                           "Clavinet", "Celesta", "Glockenspiel", "Music Box", "Vibraphone",
+                                           "Marimba", "Xylophone", "Tubular Bells", "Dulcimer"
+                                       ])],
+                                       value=0)
+                
+                velocity = gr.Slider(label="Velocity", 
+                                    minimum=1, 
+                                    maximum=127, 
+                                    value=80, 
+                                    step=1)
+            
+            # Program change button
+            program_change_button = gr.Button("Send Program Change")
+            program_change_button.click(
+                fn=lambda inst, chan: midi_manager.send_program_change(inst, chan),
+                inputs=[instrument, midi_channel],
+                outputs=None
+            )
+    
     app.queue().launch(server_port=opt.port, share=opt.share, inbrowser=True, ssr_mode=False)
-    thread_pool.shutdown()
+    
+    # Clean up MIDI connections when the app closes
+    midi_manager.close()