Update app.py

app.py

@@ -6,38 +6,69 @@ import librosa
 import soundfile as sf
 import os
 
-class SimpleMP3Humanizer:
+class AdvancedMP3Humanizer:
     def __init__(self):
+        # Enhanced instrument sets with better sound combinations
         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
+            "pop": [
+                {"program": 0, "name": "Drums", "is_drum": True, "role": "rhythm"},
+                {"program": 33, "name": "Bass Guitar", "is_drum": False, "role": "bass"},
+                {"program": 25, "name": "Acoustic Guitar", "is_drum": False, "role": "chords"},
+                {"program": 1, "name": "Piano", "is_drum": False, "role": "melody"},
+                {"program": 54, "name": "Synth Voice", "is_drum": False, "role": "pad"}
+            ],
+            "electronic": [
+                {"program": 0, "name": "Electronic Drums", "is_drum": True, "role": "rhythm"},
+                {"program": 39, "name": "Synth Bass", "is_drum": False, "role": "bass"},
+                {"program": 81, "name": "Lead Synth", "is_drum": False, "role": "melody"},
+                {"program": 89, "name": "Warm Pad", "is_drum": False, "role": "pad"},
+                {"program": 55, "name": "Orchestral Hit", "is_drum": False, "role": "accent"}
+            ],
+            "rock": [
+                {"program": 0, "name": "Rock Drums", "is_drum": True, "role": "rhythm"},
+                {"program": 33, "name": "Electric Bass", "is_drum": False, "role": "bass"},
+                {"program": 30, "name": "Distortion Guitar", "is_drum": False, "role": "rhythm"},
+                {"program": 27, "name": "Clean Guitar", "is_drum": False, "role": "melody"},
+                {"program": 49, "name": "String Ensemble", "is_drum": False, "role": "pad"}
+            ],
+            "cinematic": [
+                {"program": 0, "name": "Orchestral Drums", "is_drum": True, "role": "rhythm"},
+                {"program": 48, "name": "String Ensemble", "is_drum": False, "role": "pad"},
+                {"program": 61, "name": "French Horn", "is_drum": False, "role": "melody"},
+                {"program": 5, "name": "Electric Piano", "is_drum": False, "role": "chords"},
+                {"program": 91, "name": "Atmosphere Pad", "is_drum": False, "role": "background"}
+            ]
         }
     
     def mp3_to_humanized_mp3(self, mp3_path, style="pop", intensity=0.7):
-        """Convert MP3 to humanized MP3 in one step"""
+        """Convert MP3 to humanized MP3 with better sounds"""
         try:
-            # Load the MP3
+            # Load the MP3 with better analysis
             y, sr = librosa.load(mp3_path, sr=22050, mono=True)
             duration = len(y) / sr
             
-            # Create MIDI
+            # Create MIDI with better timing
             midi = pretty_midi.PrettyMIDI()
             
-            # Add instruments
-            for program in self.style_presets[style]:
-                is_drum = (program == 0)
-                instrument = pretty_midi.Instrument(program=program, is_drum=is_drum)
+            # Add enhanced instruments
+            for inst_info in self.style_presets[style]:
+                instrument = pretty_midi.Instrument(
+                    program=inst_info["program"],
+                    is_drum=inst_info["is_drum"],
+                    name=inst_info["name"]
+                )
                 midi.instruments.append(instrument)
             
-            # Create simple music based on audio
-            self.create_simple_music(midi, y, sr, duration, style, intensity)
+            # Extract musical elements from the audio
+            tempo, beats, melody_info = self.analyze_audio(y, sr)
             
-            # Add human feel
-            self.add_human_touch(midi, intensity)
+            # Create enhanced musical arrangement
+            self.create_enhanced_music(midi, y, sr, duration, style, intensity, tempo, beats, melody_info)
             
-            # Convert to audio
+            # Add advanced humanization
+            self.advanced_humanization(midi, intensity)
+            
+            # Synthesize with better sound quality
             audio_data = midi.synthesize()
             
             return audio_data, sr
@@ -45,44 +76,170 @@ class SimpleMP3Humanizer:
         except Exception as e:
             raise Exception(f"Conversion failed: {str(e)}")
     
-    def create_simple_music(self, midi, y, sr, duration, style, intensity):
-        """Create basic musical structure"""
-        # Create beats
-        num_beats = max(8, min(32, int(duration * 2)))  # 2 beats per second
-        beat_times = np.linspace(0, duration, num_beats)
+    def analyze_audio(self, y, sr):
+        """Enhanced audio analysis"""
+        try:
+            # Get tempo and beats
+            tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr, units='time')
+            
+            # Detect melody using multiple methods
+            onset_frames = librosa.onset.onset_detect(y=y, sr=sr, hop_length=512, delta=0.1)
+            onset_times = librosa.frames_to_time(onset_frames, sr=sr, hop_length=512)
+            
+            # Simple pitch detection for melody
+            melody_contour = []
+            for onset_time in onset_times[:20]:  # Analyze first 20 onsets
+                start_idx = int(onset_time * sr)
+                end_idx = min(start_idx + int(0.3 * sr), len(y))
+                if end_idx > start_idx:
+                    segment = y[start_idx:end_idx]
+                    freq = self.detect_strongest_frequency(segment, sr)
+                    if 100 < freq < 800:
+                        melody_contour.append(freq)
+            
+            return tempo, beat_frames, melody_contour
+            
+        except:
+            # Fallback values
+            return 120, np.linspace(0, 10, 20), [440, 523, 659, 784]  # A, C, E, G frequencies
+    
+    def detect_strongest_frequency(self, segment, sr):
+        """Detect the strongest frequency in a segment"""
+        try:
+            # Apply windowing
+            window = np.hanning(len(segment))
+            segment_windowed = segment * window
+            
+            # FFT analysis
+            fft = np.fft.rfft(segment_windowed)
+            freqs = np.fft.rfftfreq(len(segment_windowed), 1/sr)
+            mags = np.abs(fft)
+            
+            # Find strongest frequency in vocal range
+            mask = (freqs > 80) & (freqs < 1000)
+            if np.any(mask):
+                peak_idx = np.argmax(mags[mask])
+                return freqs[mask][peak_idx]
+        except:
+            pass
+        return 440  # Default to A4
+    
+    def create_enhanced_music(self, midi, y, sr, duration, style, intensity, tempo, beats, melody_contour):
+        """Create realistic musical arrangement"""
+        instruments = {inst.name: inst for inst in midi.instruments}
         
-        instruments = midi.instruments
+        # Create better beat structure
+        if len(beats) > 0:
+            beat_times = beats[:min(32, len(beats))]
+        else:
+            beat_times = np.linspace(0, min(duration, 16), 16)
         
-        # 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))
+        # Enhanced drum patterns
+        if "Drums" in instruments:
+            self.create_advanced_drums(instruments["Drums"], beat_times, style)
         
-        # 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))
+        # Better bass lines
+        bass_instruments = [inst for inst in midi.instruments if not inst.is_drum and inst.program in [33, 34, 35, 36, 37, 38, 39]]
+        if bass_instruments:
+            self.create_melodic_bass(bass_instruments[0], beat_times, melody_contour)
         
-        # Add melody
-        melody_instruments = [inst for inst in instruments if not inst.is_drum and inst.program not in range(32, 40)]
+        # Realistic melody extraction and creation
+        melody_instruments = [inst for inst in midi.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))
+            self.create_adaptive_melody(melody_instruments[0], y, sr, duration, melody_contour, style)
+        
+        # Chordal accompaniment
+        chord_instruments = [inst for inst in midi.instruments if not inst.is_drum and inst not in bass_instruments and inst not in melody_instruments]
+        for inst in chord_instruments:
+            self.create_harmonic_background(inst, beat_times, style)
+    
+    def create_advanced_drums(self, drums, beat_times, style):
+        """Create style-appropriate drum patterns"""
+        for i, time in enumerate(beat_times):
+            # Always add kick on beat 1
+            if i % 4 == 0:
+                drums.notes.append(self.create_note(36, 95, time, 0.3))  # Kick
+            
+            # Style-specific snare patterns
+            if style == "rock" and i % 4 == 2:
+                drums.notes.append(self.create_note(38, 90, time, 0.25))  # Snare
+            elif style == "pop" and i % 4 in [2, 3]:
+                drums.notes.append(self.create_note(38, 85, time + 0.05, 0.2))  # Snare with offset
+            elif style == "electronic" and i % 2 == 1:
+                drums.notes.append(self.create_note(38, 80, time, 0.15))  # Electronic snare
+            
+            # Hi-hat patterns
+            if style in ["pop", "electronic"]:
+                if i % 2 == 0:  # Every other beat
+                    drums.notes.append(self.create_note(42, 70, time, 0.1))  # Closed hi-hat
+                if style == "electronic" and i % 4 == 0:
+                    drums.notes.append(self.create_note(46, 75, time + 0.2, 0.3))  # Open hi-hat
+            
+            # Additional percussion
+            if style == "cinematic" and i % 8 == 0:
+                drums.notes.append(self.create_note(49, 80, time, 0.5))  # Crash cymbal
+    
+    def create_melodic_bass(self, bass, beat_times, melody_contour):
+        """Create melodic bass lines that follow the music"""
+        if len(melody_contour) > 0:
+            # Use detected melody to create bass line
+            base_note = self.freq_to_midi(np.median(melody_contour)) - 12
+            bass_scale = [base_note, base_note + 2, base_note + 4, base_note + 5, base_note + 7]
+        else:
+            # Fallback bass scale
+            bass_scale = [36, 38, 41, 43, 48]
+        
+        for i, time in enumerate(beat_times[::2]):  # Every other beat
+            if i < len(bass_scale):
+                note_pitch = bass_scale[i % len(bass_scale)]
+                # Vary velocity for expression
+                velocity = 80 + (i % 3) * 10
+                bass.notes.append(self.create_note(note_pitch, velocity, time, 0.9))
+    
+    def create_adaptive_melody(self, melody, y, sr, duration, melody_contour, style):
+        """Create melody that adapts to the original audio"""
+        if len(melody_contour) > 0:
+            # Use detected frequencies to create melody
+            for i, freq in enumerate(melody_contour[:16]):  # Use first 16 detected frequencies
+                midi_note = self.freq_to_midi(freq)
+                if 48 <= midi_note <= 84:  # Reasonable melody range
+                    time = (i / len(melody_contour)) * min(duration, 8)  # Spread over 8 seconds max
+                    duration_val = 0.3 + (i % 3) * 0.2  # Vary note durations
+                    melody.notes.append(self.create_note(midi_note, 75 + (i % 4)*5, time, duration_val))
+        else:
+            # Create melodic pattern based on style
+            if style == "pop":
+                melody_notes = [60, 64, 67, 72, 67, 64, 60, 65]  # C major arpeggio
+            elif style == "electronic":
+                melody_notes = [65, 69, 72, 77, 72, 69, 65, 70]  # F major with tension
+            elif style == "rock":
+                melody_notes = [59, 62, 65, 67, 65, 62, 59, 64]  # B minor pentatonic
+            else:  # cinematic
+                melody_notes = [60, 63, 67, 70, 67, 63, 60, 65]  # C minor arpeggio
+            
+            for i, note_pitch in enumerate(melody_notes):
+                time = (i / len(melody_notes)) * min(duration, 8)
+                melody.notes.append(self.create_note(note_pitch, 80, time, 0.5))
+    
+    def create_harmonic_background(self, instrument, beat_times, style):
+        """Create chordal harmony"""
+        if style == "pop":
+            chords = [[60, 64, 67], [65, 69, 72], [67, 71, 74], [62, 65, 69]]  # C, F, G, Am
+        elif style == "electronic":
+            chords = [[65, 69, 72], [70, 74, 77], [72, 76, 79], [67, 70, 74]]  # F, Bb, C, Gm
+        elif style == "rock":
+            chords = [[59, 62, 65], [64, 67, 71], [65, 69, 72], [62, 65, 69]]  # Bm, Em, F, Am
+        else:  # cinematic
+            chords = [[60, 63, 67], [65, 68, 72], [67, 70, 74], [62, 65, 69]]  # Cm, Fm, Gm, Ab
+        
+        for i, time in enumerate(beat_times[::4]):  # Every 4 beats
+            chord = chords[i % len(chords)]
+            for note_pitch in chord:
+                instrument.notes.append(self.create_note(note_pitch, 60, time, 2.0))
+    
+    def freq_to_midi(self, frequency):
+        """Convert frequency to MIDI note number"""
+        return int(69 + 12 * np.log2(frequency / 440.0))
     
     def create_note(self, pitch, velocity, start, duration):
         """Helper to create a note"""
@@ -93,32 +250,40 @@ class SimpleMP3Humanizer:
             end=start + duration
         )
     
-    def add_human_touch(self, midi, intensity):
-        """Add humanization to the music"""
+    def advanced_humanization(self, midi, intensity):
+        """Advanced humanization with more natural variations"""
         for instrument in midi.instruments:
+            # Different humanization for different instrument types
+            if instrument.is_drum:
+                humanization_factor = 0.8  # Less humanization for drums
+            elif instrument.program in range(32, 40):  # Bass instruments
+                humanization_factor = 0.6
+            else:  # Melody/harmony instruments
+                humanization_factor = 1.2
+            
             for note in instrument.notes:
-                # Random timing
-                note.start += np.random.normal(0, 0.02 * intensity)
-                note.start = max(0, note.start)
+                # Timing variations (different for different instruments)
+                timing_variation = np.random.normal(0, 0.03 * intensity * humanization_factor)
+                note.start = max(0, note.start + timing_variation)
                 
-                # Random velocity
-                note.velocity += int(np.random.normal(0, 10 * intensity))
-                note.velocity = max(40, min(127, note.velocity))
+                # Velocity variations (more expressive)
+                vel_variation = np.random.normal(0, 12 * intensity * humanization_factor)
+                note.velocity = max(40, min(127, note.velocity + int(vel_variation)))
                 
-                # Random duration for non-drums
+                # Duration variations (except drums)
                 if not instrument.is_drum:
-                    note.end += np.random.normal(0, 0.05 * intensity)
-                    note.end = max(note.start + 0.1, note.end)
+                    dur_variation = np.random.normal(0, 0.08 * intensity * humanization_factor)
+                    note.end = max(note.start + 0.1, note.end + dur_variation)
 
 def convert_mp3(input_mp3, style, intensity):
     """Main conversion function"""
     if input_mp3 is None:
         return None, "Please upload an MP3 file"
     
-    converter = SimpleMP3Humanizer()
+    converter = AdvancedMP3Humanizer()
     
     try:
-        # Convert to humanized MP3
+        # Convert to humanized MP3 with better sounds
         audio_data, sr = converter.mp3_to_humanized_mp3(input_mp3, style, intensity)
         
         # Save as temporary MP3 file
@@ -130,11 +295,13 @@ def convert_mp3(input_mp3, style, intensity):
     except Exception as e:
         return None, f"❌ Error: {str(e)}"
 
-# Simple and compatible interface
-with gr.Blocks(theme=gr.themes.Soft(), title="MP3 Humanizer") as demo:
+# Enhanced interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced MP3 Humanizer") as demo:
     gr.Markdown("""
-    # 🎵 MP3 Humanizer
-    **Upload AI Music → Get Human Version → Download MP3**
+    # 🎵 Advanced MP3 Humanizer
+    **Transform AI Music into Realistic Human Performances**
+    
+    *Now with better instrument sounds and realistic musical arrangements!*
     """)
     
     with gr.Row():
@@ -146,28 +313,30 @@ with gr.Blocks(theme=gr.themes.Soft(), title="MP3 Humanizer") as demo:
                 label="Upload MP3 File"
             )
             
-            gr.Markdown("### 2. Choose Settings")
+            gr.Markdown("### 2. Choose Music Style")
             style = gr.Radio(
                 ["pop", "electronic", "rock", "cinematic"],
                 value="pop",
-                label="Music Style"
+                label="Select Style",
+                info="Each style uses different instruments and patterns"
             )
             
             intensity = gr.Slider(
                 0.1, 1.0, value=0.7,
-                label="Human Feel Intensity"
+                label="Human Feel Intensity",
+                info="Higher = more natural human variations"
             )
             
             convert_btn = gr.Button(
-                "✨ Convert to Human Version",
+                "🎹 Create Human Version",
                 variant="primary",
                 size="lg"
             )
         
         with gr.Column(scale=1):
-            gr.Markdown("### 3. Download Result")
+            gr.Markdown("### 3. Your Humanized Song")
             output_audio = gr.Audio(
-                label="Your Humanized Song",
+                label="Enhanced Human Version",
                 type="filepath",
                 interactive=False
             )
@@ -177,26 +346,34 @@ with gr.Blocks(theme=gr.themes.Soft(), title="MP3 Humanizer") as demo:
                 interactive=False
             )
     
-    # Simple instructions
-    with gr.Accordion("📖 How to Use", open=True):
+    # Enhanced instructions
+    with gr.Accordion("🎸 What's New in This Version", open=True):
         gr.Markdown("""
-        1. **Upload** your AI-generated MP3 file
-        2. **Choose** your preferred music style
-        3. **Adjust** the human feel slider
-        4. **Click Convert** and wait a few seconds
-        5. **Play the preview** to hear your humanized song
-        6. **Click the download icon** in the audio player to save your MP3
+        **Major Improvements:**
         
-        That's it! You'll get a complete MP3 file with drums, bass, melody, and human-sounding timing.
+        🥁 **Better Drum Patterns**: Style-specific rhythms with kicks, snares, hi-hats
+        🎸 **Real Bass Lines**: Melodic bass that follows the music
+        🎹 **Adaptive Melodies**: Extracts and enhances melodies from your audio
+        🎻 **Rich Harmony**: Chord progressions and background pads
+        🎛️ **Advanced Humanization**: Different variations for each instrument type
+        
+        **Each style now includes:**
+        - **Pop**: Drums, Bass Guitar, Acoustic Guitar, Piano, Synth Voice
+        - **Electronic**: Electronic Drums, Synth Bass, Lead Synth, Warm Pad, Orchestral Hits
+        - **Rock**: Rock Drums, Electric Bass, Distortion & Clean Guitars, Strings
+        - **Cinematic**: Orchestral Drums, String Ensemble, French Horn, Electric Piano, Atmosphere
+        
+        **How to use:**
+        1. Upload your AI-generated MP3
+        2. Choose the style that matches your music
+        3. Adjust human feel (0.7 is recommended)
+        4. Click convert and wait ~10 seconds
+        5. Play the preview and download your enhanced MP3!
         """)
     
     # Conversion process
-    def process_conversion(input_mp3, style, intensity):
-        output_path, message = convert_mp3(input_mp3, style, intensity)
-        return output_path, message
-    
     convert_btn.click(
-        fn=process_conversion,
+        fn=convert_mp3,
         inputs=[input_audio, style, intensity],
         outputs=[output_audio, status]
     )