Update app.py

app.py

@@ -1,70 +1,107 @@
 import streamlit as st
 import streamlit.components.v1 as components
-import json
-from pathlib import Path
-import time
 import subprocess
-import sys
+import time
+import os
+import threading
+from queue import Queue
+import json
 
-def check_midi_prerequisites():
-    """Check and report MIDI system status"""
-    issues = []
-    solutions = []
-    
+def install_fluidsynth():
+    """Check and install FluidSynth if needed"""
     try:
-        import rtmidi
-    except ImportError:
-        issues.append("python-rtmidi is not installed")
-        solutions.append("pip install python-rtmidi")
-    except OSError as e:
-        issues.append(f"MIDI system error: {str(e)}")
-        solutions.extend([
-            "sudo apt-get install libasound2-dev",
-            "sudo apt-get install alsa-utils",
-            "sudo modprobe snd-seq-midi"
-        ])
-    
-    if issues:
-        st.error("MIDI System Issues Detected")
-        st.write("Problems found:")
-        for issue in issues:
-            st.write(f"- {issue}")
-            
-        st.write("Try these solutions:")
-        for solution in solutions:
-            st.code(solution)
-            
-        st.write("After installing prerequisites, restart the application.")
-        return False
+        subprocess.run(['fluidsynth', '--version'], capture_output=True)
+        return True
+    except FileNotFoundError:
+        st.error("FluidSynth not found. Installing required packages...")
+        try:
+            subprocess.run(['sudo', 'apt-get', 'update'], check=True)
+            subprocess.run(['sudo', 'apt-get', 'install', '-y', 'fluidsynth'], check=True)
+            return True
+        except subprocess.CalledProcessError as e:
+            st.error(f"Failed to install FluidSynth: {str(e)}")
+            st.code("sudo apt-get install -y fluidsynth")
+            return False
+
+def download_soundfont():
+    """Download a free soundfont if not present"""
+    soundfont_path = "GeneralUser GS v1.471.sf2"
+    if not os.path.exists(soundfont_path):
+        st.info("Downloading soundfont...")
+        try:
+            subprocess.run([
+                'wget', 
+                'https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/musicbox/GeneralUser%20GS%20v1.471.sf2',
+                '-O', 
+                soundfont_path
+            ], check=True)
+            return True
+        except subprocess.CalledProcessError as e:
+            st.error(f"Failed to download soundfont: {str(e)}")
+            return False
     return True
 
-def create_midi_output():
-    """Initialize MIDI output with fallback options"""
-    try:
-        import rtmidi
-        midi_out = rtmidi.MidiOut()
-        available_ports = midi_out.get_ports()
-        
-        if available_ports:
-            st.sidebar.write("Available MIDI ports:", available_ports)
-            selected_port = st.sidebar.selectbox(
-                "Select MIDI Output", 
-                range(len(available_ports)), 
-                format_func=lambda x: available_ports[x]
+class FluidSynthPlayer:
+    def __init__(self, soundfont_path):
+        self.soundfont_path = soundfont_path
+        self.process = None
+        self.event_queue = Queue()
+        self.running = False
+
+    def start(self):
+        """Start FluidSynth process"""
+        try:
+            self.process = subprocess.Popen(
+                [
+                    'fluidsynth',
+                    '-a', 'pulseaudio',  # Use PulseAudio
+                    '-g', '2.0',         # Gain (volume)
+                    self.soundfont_path
+                ],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1
             )
-            midi_out.open_port(selected_port)
-        else:
-            st.sidebar.warning("No hardware MIDI ports found. Creating virtual port.")
+            self.running = True
+            threading.Thread(target=self._process_events, daemon=True).start()
+            return True
+        except Exception as e:
+            st.error(f"Failed to start FluidSynth: {str(e)}")
+            return False
+
+    def stop(self):
+        """Stop FluidSynth process"""
+        self.running = False
+        if self.process:
+            self.process.terminate()
+            self.process.wait()
+
+    def _process_events(self):
+        """Process MIDI events from queue"""
+        while self.running:
+            try:
+                event = self.event_queue.get(timeout=0.1)
+                if event['type'] == 'noteOn':
+                    self._send_command(f"noteon 0 {event['note']} {event['velocity']}")
+                elif event['type'] == 'noteOff':
+                    self._send_command(f"noteoff 0 {event['note']}")
+            except:
+                continue
+
+    def _send_command(self, command):
+        """Send command to FluidSynth process"""
+        if self.process and self.process.poll() is None:
             try:
-                midi_out.open_virtual_port("Virtual MIDI Output")
-            except rtmidi.SystemError:
-                st.sidebar.error("Could not create virtual MIDI port. Running in simulation mode.")
-                return None
-        return midi_out
-    except Exception as e:
-        st.sidebar.error(f"MIDI system unavailable: {str(e)}")
-        st.sidebar.info("Running in simulation mode (no MIDI output)")
-        return None
+                self.process.stdin.write(command + '\n')
+                self.process.stdin.flush()
+            except:
+                pass
+
+    def queue_event(self, event):
+        """Add MIDI event to queue"""
+        self.event_queue.put(event)
 
 def get_piano_html():
     """Return the HTML content for the piano keyboard"""
@@ -98,7 +135,6 @@ def get_piano_html():
 
         <script src="https://cdnjs.cloudflare.com/ajax/libs/qwerty-hancock/0.10.0/qwerty-hancock.min.js"></script>
         <script>
-            // Initialize keyboard
             const keyboard = new QwertyHancock({
                 id: 'keyboard',
                 width: 800,
@@ -110,7 +146,6 @@ def get_piano_html():
                 activeColour: '#88c6ff'
             });
 
-            // Note to MIDI number mapping
             const noteToMidi = {
                 'C4': 60, 'C#4': 61, 'D4': 62, 'D#4': 63, 'E4': 64, 'F4': 65,
                 'F#4': 66, 'G4': 67, 'G#4': 68, 'A4': 69, 'A#4': 70, 'B4': 71,
@@ -118,7 +153,6 @@ def get_piano_html():
                 'F#5': 78, 'G5': 79, 'G#5': 80, 'A5': 81, 'A#5': 82, 'B5': 83
             };
 
-            // Add note labels
             function addNoteLabels() {
                 const container = document.getElementById('keyboard');
                 const whiteKeys = container.querySelectorAll('[data-note-type="white"]');
@@ -141,7 +175,6 @@ def get_piano_html():
                 });
             }
 
-            // Send MIDI events to Streamlit
             keyboard.keyDown = function(note, frequency) {
                 const midiNote = noteToMidi[note];
                 const event = {
@@ -162,7 +195,6 @@ def get_piano_html():
                 window.parent.postMessage({type: 'midiEvent', data: event}, '*');
             };
 
-            // Wait for the keyboard to be rendered
             setTimeout(addNoteLabels, 100);
         </script>
     </body>
@@ -170,18 +202,26 @@ def get_piano_html():
     """
 
 def main():
-    st.title("MIDI Piano Keyboard")
+    st.title("Piano Keyboard with FluidSynth")
     st.write("Click keys or use your computer keyboard (A-K and W-U for white and black keys)")
     
-    # Check MIDI prerequisites
-    if not check_midi_prerequisites():
+    # Check and install FluidSynth if needed
+    if not install_fluidsynth():
         return
     
-    # Initialize MIDI output
-    midi_out = create_midi_output()
+    # Download soundfont if needed
+    if not download_soundfont():
+        return
     
-    # Create a placeholder for MIDI messages
-    midi_message_placeholder = st.empty()
+    # Initialize FluidSynth
+    if 'synth' not in st.session_state:
+        st.session_state.synth = FluidSynthPlayer("GeneralUser GS v1.471.sf2")
+        if not st.session_state.synth.start():
+            st.error("Failed to start FluidSynth. Please check your audio setup.")
+            return
+    
+    # Create a placeholder for messages
+    message_placeholder = st.empty()
     
     # Display the piano keyboard
     components.html(
@@ -195,20 +235,11 @@ def main():
         st.session_state.midi_events = []
     
     def handle_midi_event(event):
-        if midi_out is None:
-            # Simulation mode - just display the events
-            if event['type'] == 'noteOn':
-                midi_message_placeholder.write(f"Simulated Note On: {event['note']} (No MIDI Output)")
-            else:
-                midi_message_placeholder.write(f"Simulated Note Off: {event['note']} (No MIDI Output)")
-            return
-            
+        st.session_state.synth.queue_event(event)
         if event['type'] == 'noteOn':
-            midi_out.send_message([0x90, event['note'], event['velocity']])
-            midi_message_placeholder.write(f"Note On: {event['note']}")
-        elif event['type'] == 'noteOff':
-            midi_out.send_message([0x80, event['note'], event['velocity']])
-            midi_message_placeholder.write(f"Note Off: {event['note']}")
+            message_placeholder.write(f"Note On: {event['note']}")
+        else:
+            message_placeholder.write(f"Note Off: {event['note']}")
     
     # JavaScript callback handler
     components.html(
@@ -230,5 +261,12 @@ def main():
         height=0
     )
 
+    # Cleanup on session end
+    def cleanup():
+        if 'synth' in st.session_state:
+            st.session_state.synth.stop()
+    
+    st.on_session_ended(cleanup)
+
 if __name__ == "__main__":
     main()