Update app.py

app.py

@@ -2,316 +2,211 @@ import gradio as gr
 import pretty_midi
 import numpy as np
 import tempfile
-import os
 import librosa
 import soundfile as sf
-from pathlib import Path
 
-class MP3ToHumanizedMP3:
+class SimpleMP3Humanizer:
     def __init__(self):
-        self.instrument_sets = {
-            "pop": [
-                {"program": 0, "name": "Drums", "is_drum": True, "volume": 0.8},
-                {"program": 33, "name": "Bass Guitar", "is_drum": False, "volume": 0.7},
-                {"program": 25, "name": "Acoustic Guitar", "is_drum": False, "volume": 0.6},
-                {"program": 1, "name": "Piano", "is_drum": False, "volume": 0.5},
-            ],
-            "electronic": [
-                {"program": 0, "name": "Drums", "is_drum": True, "volume": 0.9},
-                {"program": 39, "name": "Synth Bass", "is_drum": False, "volume": 0.8},
-                {"program": 81, "name": "Lead Synth", "is_drum": False, "volume": 0.7},
-                {"program": 89, "name": "Pad", "is_drum": False, "volume": 0.4},
-            ],
-            "rock": [
-                {"program": 0, "name": "Drums", "is_drum": True, "volume": 0.9},
-                {"program": 33, "name": "Bass", "is_drum": False, "volume": 0.7},
-                {"program": 30, "name": "Distortion Guitar", "is_drum": False, "volume": 0.8},
-                {"program": 27, "name": "Clean Guitar", "is_drum": False, "volume": 0.6},
-            ],
-            "cinematic": [
-                {"program": 0, "name": "Drums", "is_drum": True, "volume": 0.6},
-                {"program": 48, "name": "String Ensemble", "is_drum": False, "volume": 0.8},
-                {"program": 61, "name": "French Horn", "is_drum": False, "volume": 0.7},
-                {"program": 5, "name": "Electric Piano", "is_drum": False, "volume": 0.5},
-            ]
+        self.style_presets = {
+            "pop": [0, 33, 25, 1],      # Drums, Bass, Guitar, Piano
+            "electronic": [0, 39, 81, 89],  # Drums, Synth Bass, Lead, Pad
+            "rock": [0, 33, 30, 27],    # Drums, Bass, Distortion Guitar, Clean Guitar
+            "cinematic": [0, 48, 61, 5] # Drums, Strings, Horn, Piano
         }
     
-    def create_full_song(self, audio_path, style="pop", intensity=0.7):
-        """Convert MP3 to a complete humanized song - SIMPLIFIED VERSION"""
+    def mp3_to_humanized_mp3(self, mp3_path, style="pop", intensity=0.7):
+        """Convert MP3 to humanized MP3 in one step"""
         try:
-            # Load original audio
-            y, sr = librosa.load(audio_path, sr=22050, mono=True)
+            # Load the MP3
+            y, sr = librosa.load(mp3_path, sr=22050, mono=True)
+            duration = len(y) / sr
             
-            # Create MIDI structure
+            # Create MIDI
             midi = pretty_midi.PrettyMIDI()
             
-            # Add instruments based on style
-            for inst_info in self.instrument_sets[style]:
-                instrument = pretty_midi.Instrument(
-                    program=inst_info["program"],
-                    is_drum=inst_info["is_drum"],
-                    name=inst_info["name"]
-                )
+            # Add instruments
+            for program in self.style_presets[style]:
+                is_drum = (program == 0)
+                instrument = pretty_midi.Instrument(program=program, is_drum=is_drum)
                 midi.instruments.append(instrument)
             
-            # SIMPLIFIED: Extract basic rhythm and melody
-            self.simple_music_extraction(midi, y, sr, style, intensity)
+            # Create simple music based on audio
+            self.create_simple_music(midi, y, sr, duration, style, intensity)
             
-            # Humanize the performance
-            self.humanize_performance(midi, intensity)
+            # Add human feel
+            self.add_human_touch(midi, intensity)
             
-            # Synthesize to audio
+            # Convert to audio
             audio_data = midi.synthesize()
             
             return audio_data, sr
             
         except Exception as e:
-            raise Exception(f"Song creation failed: {str(e)}")
+            raise Exception(f"Conversion failed: {str(e)}")
     
-    def simple_music_extraction(self, midi, y, sr, style, intensity):
-        """Simplified music extraction without complex dependencies"""
-        try:
-            # Get basic tempo and beats
-            tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr, units='time')
-            if len(beat_frames) > 0:
-                beat_times = beat_frames
-            else:
-                # Fallback: create artificial beats
-                duration = len(y) / sr
-                beat_times = np.linspace(0, duration, 16)
-            
-            instruments = midi.instruments
-            
-            # Add simple drum pattern
-            drum_instrument = next((inst for inst in instruments if inst.is_drum), None)
-            if drum_instrument:
-                self.add_simple_drums(drum_instrument, beat_times, style)
-            
-            # Add simple bass line
-            bass_instrument = next((inst for inst in instruments if not inst.is_drum and 32 <= inst.program <= 39), None)
-            if bass_instrument:
-                self.add_simple_bass(bass_instrument, beat_times)
-            
-            # Add simple melody
-            lead_instrument = next((inst for inst in instruments if not inst.is_drum and inst != bass_instrument), None)
-            if lead_instrument:
-                self.add_simple_melody(lead_instrument, y, sr, intensity)
-                
-        except Exception as e:
-            # If extraction fails, add a basic pattern
-            self.add_fallback_pattern(midi, y, sr)
-    
-    def add_simple_drums(self, drums, beat_times, style):
-        """Add basic drum pattern"""
-        for i, beat_time in enumerate(beat_times[:16]):  # First 16 beats
-            # Kick on beat 1
-            if i % 4 == 0:
-                note = pretty_midi.Note(
-                    velocity=90, pitch=36, start=beat_time, end=beat_time + 0.3
-                )
-                drums.notes.append(note)
-            
-            # Snare on beat 3
-            if i % 4 == 2:
-                note = pretty_midi.Note(
-                    velocity=80, pitch=38, start=beat_time, end=beat_time + 0.2
-                )
-                drums.notes.append(note)
-            
-            # Hi-hat on all beats for electronic/pop
-            if style in ["electronic", "pop"] and i % 2 == 0:
-                note = pretty_midi.Note(
-                    velocity=60, pitch=42, start=beat_time, end=beat_time + 0.1
-                )
-                drums.notes.append(note)
-    
-    def add_simple_bass(self, bass, beat_times):
-        """Add simple bass line"""
-        bass_notes = [36, 38, 41, 43]  # C, D, F, G
+    def create_simple_music(self, midi, y, sr, duration, style, intensity):
+        """Create basic musical structure"""
+        # Create beats
+        num_beats = int(duration * 2)  # 2 beats per second
+        if num_beats < 8:
+            num_beats = 8
+        if num_beats > 32:
+            num_beats = 32
+            
+        beat_times = np.linspace(0, duration, num_beats)
         
-        for i, beat_time in enumerate(beat_times[:8]):
-            if i % 2 == 0:  # Every other beat
-                note_pitch = bass_notes[i % len(bass_notes)]
-                note = pretty_midi.Note(
-                    velocity=80,
-                    pitch=note_pitch,
-                    start=beat_time,
-                    end=beat_time + 0.8
-                )
-                bass.notes.append(note)
-    
-    def add_simple_melody(self, lead, y, sr, intensity):
-        """Add simple melody using basic pitch detection"""
-        try:
-            # Use simple onset detection
-            onset_frames = librosa.onset.onset_detect(y=y, sr=sr, hop_length=512)
-            onset_times = librosa.frames_to_time(onset_frames, sr=sr, hop_length=512)
-            
-            melody_notes = [60, 62, 64, 65, 67, 69, 71, 72]  # C Major scale
-            
-            for i, onset_time in enumerate(onset_times[:12]):  # First 12 onsets
-                note_pitch = melody_notes[i % len(melody_notes)]
-                note = pretty_midi.Note(
-                    velocity=np.random.randint(70, 90),
-                    pitch=note_pitch,
-                    start=onset_time,
-                    end=onset_time + 0.5
-                )
-                lead.notes.append(note)
-                
-        except:
-            # Fallback: add a simple arpeggio
-            for i in range(8):
-                note = pretty_midi.Note(
-                    velocity=80,
-                    pitch=60 + i,
-                    start=i * 0.5,
-                    end=i * 0.5 + 0.4
-                )
-                lead.notes.append(note)
-    
-    def add_fallback_pattern(self, midi, y, sr):
-        """Add a basic musical pattern if extraction fails"""
-        duration = len(y) / sr
-        instruments = [inst for inst in midi.instruments if not inst.is_drum]
+        instruments = midi.instruments
+        
+        # Add drums
+        drums = next((inst for inst in instruments if inst.is_drum), None)
+        if drums:
+            for i, time in enumerate(beat_times):
+                # Kick on strong beats
+                if i % 4 == 0:
+                    drums.notes.append(self.create_note(36, 90, time, 0.3))
+                # Snare on off-beats
+                if i % 4 == 2:
+                    drums.notes.append(self.create_note(38, 80, time, 0.2))
+                # Hi-hats for electronic/pop
+                if style in ["electronic", "pop"]:
+                    drums.notes.append(self.create_note(42, 70, time, 0.1))
+        
+        # Add bass
+        bass = next((inst for inst in instruments if not inst.is_drum and 32 <= inst.program <= 39), None)
+        if bass:
+            bass_notes = [36, 38, 41, 43, 45, 48]  # Simple bass line
+            for i, time in enumerate(beat_times[::2]):  # Every other beat
+                if i < len(bass_notes):
+                    bass.notes.append(self.create_note(bass_notes[i], 85, time, 0.8))
         
-        if instruments:
-            lead = instruments[0]
-            # Add a simple scale
-            for i in range(8):
-                note = pretty_midi.Note(
-                    velocity=80,
-                    pitch=60 + i,
-                    start=i * 0.5,
-                    end=i * 0.5 + 0.4
-                )
-                lead.notes.append(note)
+        # Add melody
+        melody_instruments = [inst for inst in instruments if not inst.is_drum and inst.program not in range(32, 40)]
+        if melody_instruments:
+            melody = melody_instruments[0]
+            melody_notes = [60, 62, 64, 65, 67, 69, 71, 72]  # C major scale
+            for i, time in enumerate(beat_times[::4]):  # Every 4 beats
+                if i < len(melody_notes):
+                    melody.notes.append(self.create_note(melody_notes[i], 80, time, 1.0))
     
-    def humanize_performance(self, midi, intensity):
-        """Add human feel to all instruments"""
+    def create_note(self, pitch, velocity, start, duration):
+        """Helper to create a note"""
+        return pretty_midi.Note(
+            velocity=velocity,
+            pitch=pitch,
+            start=start,
+            end=start + duration
+        )
+    
+    def add_human_touch(self, midi, intensity):
+        """Add humanization to the music"""
         for instrument in midi.instruments:
             for note in instrument.notes:
-                # Humanize timing
-                timing_shift = np.random.normal(0, 0.02 * intensity)
-                note.start = max(0, note.start + timing_shift)
+                # Random timing
+                note.start += np.random.normal(0, 0.02 * intensity)
+                note.start = max(0, note.start)
                 
-                # Humanize velocity
-                vel_shift = np.random.randint(-15, 15)
-                note.velocity = max(40, min(127, note.velocity + int(vel_shift * intensity)))
+                # Random velocity
+                note.velocity += int(np.random.normal(0, 10 * intensity))
+                note.velocity = max(40, min(127, note.velocity))
                 
-                # Humanize duration (except drums)
+                # Random duration for non-drums
                 if not instrument.is_drum:
-                    duration_shift = np.random.normal(0, 0.1 * intensity)
-                    note.end = max(note.start + 0.1, note.end + duration_shift)
+                    note.end += np.random.normal(0, 0.05 * intensity)
+                    note.end = max(note.start + 0.1, note.end)
 
-def process_to_mp3(files, style, intensity):
-    """Process audio files and return MP3 results"""
-    if not files:
-        return None, "Please upload audio files"
-    
-    converter = MP3ToHumanizedMP3()
-    output_files = []
+def convert_mp3(input_mp3, style, intensity):
+    """Main conversion function"""
+    if input_mp3 is None:
+        return None, "Please upload an MP3 file"
     
-    for file in files:
-        try:
-            print(f"Processing: {file.name}")
-            
-            # Create full humanized song
-            audio_data, sr = converter.create_full_song(file.name, style, intensity)
-            
-            # Save as MP3
-            mp3_path = tempfile.mktemp(suffix='_humanized.mp3')
-            sf.write(mp3_path, audio_data, sr)
-            
-            output_files.append(mp3_path)
-            print(f"Successfully created: {mp3_path}")
-            
-        except Exception as e:
-            error_msg = f"Error processing {file.name}: {str(e)}"
-            print(error_msg)
-            return None, error_msg
+    converter = SimpleMP3Humanizer()
     
-    if output_files:
-        return output_files, f"✅ Success! Created {len(output_files)} humanized MP3 files"
-    else:
-        return None, "❌ Processing failed - no files were created"
+    try:
+        # Convert to humanized MP3
+        audio_data, sr = converter.mp3_to_humanized_mp3(input_mp3, style, intensity)
+        
+        # Save as temporary MP3 file
+        output_path = tempfile.mktemp(suffix='_humanized.mp3')
+        sf.write(output_path, audio_data, sr)
+        
+        return output_path, "✅ Conversion successful! Download your humanized song below."
+        
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
 
-# Simple and robust interface
+# Clean and simple interface
 with gr.Blocks(theme=gr.themes.Soft(), title="MP3 Humanizer") as demo:
     gr.Markdown("""
     # 🎵 MP3 Humanizer
-    **Convert AI Music to Human-Sounding MP3 - No Errors!**
-    
-    Upload your AI-generated music and get back humanized MP3 files with full instrumentation.
+    **Upload AI Music → Get Human Version → Download MP3**
     """)
     
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 📁 Upload Your Music")
-            file_input = gr.File(
-                file_count="multiple",
-                file_types=[".mp3", ".wav", ".m4a", ".ogg"],
-                label="Drag and drop your audio files here"
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Upload Your AI Song")
+            input_audio = gr.Audio(
+                sources=["upload"],
+                type="filepath",
+                label="Upload MP3 File"
             )
             
+            gr.Markdown("### 2. Choose Settings")
             style = gr.Radio(
                 ["pop", "electronic", "rock", "cinematic"],
                 value="pop",
-                label="🎵 Music Style"
+                label="Music Style"
             )
             
             intensity = gr.Slider(
                 0.1, 1.0, value=0.7,
-                label="🎛️ Human Feel Intensity"
+                label="Human Feel"
             )
             
-            process_btn = gr.Button("🚀 Create Humanized MP3", variant="primary", size="lg")
+            convert_btn = gr.Button(
+                "✨ Convert to Human Version",
+                variant="primary",
+                size="lg"
+            )
         
-        with gr.Column():
-            gr.Markdown("### 📥 Your Humanized Songs")
-            file_output = gr.File(
-                file_count="multiple",
-                label="Download your humanized MP3 files"
+        with gr.Column(scale=1):
+            gr.Markdown("### 3. Download Result")
+            output_audio = gr.Audio(
+                label="Your Humanized Song",
+                type="filepath",
+                interactive=False
             )
             
-            audio_output = gr.Audio(
-                label="🎧 Preview (First File)",
-                type="filepath"
+            download_btn = gr.DownloadButton(
+                "📥 Download MP3",
+                visible=False,
+                size="lg"
             )
             
             status = gr.Textbox(
                 label="Status",
-                interactive=False,
-                max_lines=3
+                interactive=False
             )
     
-    with gr.Accordion("💡 How It Works", open=True):
-        gr.Markdown("""
-        **This version is guaranteed to work:**
-        1. **Upload** any audio file (MP3, WAV, M4A, OGG)
-        2. **Choose** your preferred music style
-        3. **Click Process** - No more scipy errors!
-        4. **Download** your humanized MP3 file
-        
-        **Each MP3 contains:**
-        - 🥁 Drum patterns
-        - 🎸 Bass lines  
-        - 🎹 Melodies and chords
-        - 🎛️ Natural human timing
-        
-        **No technical knowledge needed - just upload and download!**
-        """)
-
-    # Connect the processing
-    process_btn.click(
-        fn=process_to_mp3,
-        inputs=[file_input, style, intensity],
-        outputs=[file_output, status]
-    ).then(
-        lambda files: files[0] if files and len(files) > 0 else None,
-        inputs=[file_output],
-        outputs=[audio_output]
+    # Simple conversion process
+    def process_conversion(input_mp3, style, intensity):
+        output_path, message = convert_mp3(input_mp3, style, intensity)
+        if output_path:
+            return output_path, output_path, gr.DownloadButton(visible=True), message
+        else:
+            return None, None, gr.DownloadButton(visible=False), message
+    
+    convert_btn.click(
+        fn=process_conversion,
+        inputs=[input_audio, style, intensity],
+        outputs=[output_audio, download_btn, download_btn, status]
+    )
+    
+    # Update download button when audio is ready
+    output_audio.change(
+        lambda x: gr.DownloadButton(visible=(x is not None)),
+        inputs=[output_audio],
+        outputs=[download_btn]
     )
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch()