Update app.py

app.py

@@ -6,223 +6,302 @@ import librosa
 import soundfile as sf
 import os
 
-class AdvancedMP3Humanizer:
+class CompleteSongHumanizer:
     def __init__(self):
-        # Enhanced instrument sets with better sound combinations
-        self.style_presets = {
-            "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"}
-            ]
+        # Complete band setups for each style
+        self.band_setups = {
+            "pop": {
+                "drums": {"program": 0, "name": "Pop Drums"},
+                "bass": {"program": 33, "name": "Bass Guitar"},
+                "rhythm": {"program": 25, "name": "Acoustic Guitar"},
+                "piano": {"program": 1, "name": "Piano"},
+                "strings": {"program": 49, "name": "String Ensemble"},
+                "synth": {"program": 81, "name": "Lead Synth"}
+            },
+            "electronic": {
+                "drums": {"program": 0, "name": "EDM Drums"},
+                "bass": {"program": 39, "name": "Synth Bass"},
+                "lead": {"program": 81, "name": "Lead Synth"},
+                "pad": {"program": 89, "name": "Warm Pad"},
+                "fx": {"program": 103, "name": "FX"},
+                "chords": {"program": 5, "name": "Electric Piano"}
+            },
+            "rock": {
+                "drums": {"program": 0, "name": "Rock Drums"},
+                "bass": {"program": 33, "name": "Bass Guitar"},
+                "guitar1": {"program": 30, "name": "Distortion Guitar"},
+                "guitar2": {"program": 27, "name": "Clean Guitar"},
+                "keys": {"program": 5, "name": "Electric Piano"},
+                "strings": {"program": 48, "name": "String Ensemble"}
+            },
+            "cinematic": {
+                "drums": {"program": 0, "name": "Orchestral Percussion"},
+                "strings1": {"program": 48, "name": "String Ensemble"},
+                "strings2": {"program": 49, "name": "Slow Strings"},
+                "brass": {"program": 61, "name": "French Horn"},
+                "woodwinds": {"program": 68, "name": "Oboe"},
+                "harp": {"program": 46, "name": "Harp"}
+            }
+        }
+        
+        # Song structures
+        self.song_structures = {
+            "pop": ["intro", "verse", "chorus", "verse", "chorus", "bridge", "chorus", "outro"],
+            "electronic": ["intro", "build", "drop", "break", "build", "drop", "outro"],
+            "rock": ["intro", "verse", "chorus", "verse", "chorus", "solo", "chorus", "outro"],
+            "cinematic": ["intro", "theme", "build", "climax", "resolution", "outro"]
         }
     
-    def mp3_to_humanized_mp3(self, mp3_path, style="pop", intensity=0.7):
-        """Convert MP3 to humanized MP3 with better sounds"""
+    def create_complete_song(self, mp3_path, style="pop", intensity=0.7):
+        """Create a complete humanized song from MP3"""
         try:
-            # Load the MP3 with better analysis
+            # Load and analyze the audio
             y, sr = librosa.load(mp3_path, sr=22050, mono=True)
             duration = len(y) / sr
             
-            # Create MIDI with better timing
+            # Create MIDI object
             midi = pretty_midi.PrettyMIDI()
             
-            # 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)
+            # Setup complete band
+            band = self.setup_band(midi, style)
             
-            # Extract musical elements from the audio
-            tempo, beats, melody_info = self.analyze_audio(y, sr)
+            # Analyze audio to get musical content
+            audio_features = self.analyze_audio_features(y, sr, duration)
             
-            # Create enhanced musical arrangement
-            self.create_enhanced_music(midi, y, sr, duration, style, intensity, tempo, beats, melody_info)
+            # Create complete song structure
+            self.build_complete_song(midi, band, style, audio_features, duration, intensity)
             
-            # Add advanced humanization
-            self.advanced_humanization(midi, intensity)
+            # Apply advanced humanization
+            self.apply_complete_humanization(midi, intensity)
             
-            # Synthesize with better sound quality
+            # Synthesize to audio
             audio_data = midi.synthesize()
             
             return audio_data, sr
             
         except Exception as e:
-            raise Exception(f"Conversion failed: {str(e)}")
+            raise Exception(f"Song creation failed: {str(e)}")
     
-    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 setup_band(self, midi, style):
+        """Setup complete band instruments"""
+        band = {}
+        for role, inst_info in self.band_setups[style].items():
+            instrument = pretty_midi.Instrument(
+                program=inst_info["program"],
+                is_drum=(role == "drums"),
+                name=inst_info["name"]
+            )
+            midi.instruments.append(instrument)
+            band[role] = instrument
+        return band
     
-    def detect_strongest_frequency(self, segment, sr):
-        """Detect the strongest frequency in a segment"""
+    def analyze_audio_features(self, y, sr, duration):
+        """Extract musical features from audio"""
+        # Get tempo and beats
+        tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr, units='time')
+        
+        # Detect onsets for melody extraction
+        onset_frames = librosa.onset.onset_detect(y=y, sr=sr, hop_length=512, delta=0.08)
+        onset_times = librosa.frames_to_time(onset_frames, sr=sr, hop_length=512)
+        
+        # Extract melody contour
+        melody_contour = []
+        for onset_time in onset_times[:50]:  # Analyze first 50 onsets
+            start_idx = int(onset_time * sr)
+            end_idx = min(start_idx + int(0.4 * sr), len(y))
+            if end_idx > start_idx:
+                segment = y[start_idx:end_idx]
+                freq = self.detect_pitch(segment, sr)
+                if 100 < freq < 1000:
+                    melody_contour.append((onset_time, freq))
+        
+        # Detect energy changes for song sections
+        energy = librosa.feature.rms(y=y)[0]
+        energy_times = librosa.times_like(energy, sr=sr)
+        
+        return {
+            'tempo': tempo if tempo else 120,
+            'beats': beat_frames if len(beat_frames) > 0 else np.linspace(0, duration, 32),
+            'melody_contour': melody_contour,
+            'energy': list(zip(energy_times, energy)),
+            'duration': duration
+        }
+    
+    def detect_pitch(self, segment, sr):
+        """Detect pitch in audio 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)
+            # Simple FFT-based pitch detection
+            fft = np.fft.rfft(segment * np.hanning(len(segment)))
+            freqs = np.fft.rfftfreq(len(segment), 1/sr)
             mags = np.abs(fft)
             
-            # Find strongest frequency in vocal range
-            mask = (freqs > 80) & (freqs < 1000)
+            # Find strongest frequency in reasonable range
+            mask = (freqs > 80) & (freqs < 1200)
             if np.any(mask):
                 peak_idx = np.argmax(mags[mask])
                 return freqs[mask][peak_idx]
         except:
             pass
-        return 440  # Default to A4
+        return 440
     
-    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}
+    def build_complete_song(self, midi, band, style, features, duration, intensity):
+        """Build complete song with structure"""
+        structure = self.song_structures[style]
+        section_duration = duration / len(structure)
         
-        # 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)
+        for section_idx, section_name in enumerate(structure):
+            start_time = section_idx * section_duration
+            end_time = (section_idx + 1) * section_duration
+            
+            # Create section-specific music
+            self.create_section(
+                band, style, section_name, section_idx, 
+                start_time, end_time, features, intensity
+            )
+    
+    def create_section(self, band, style, section_name, section_idx, start_time, end_time, features, intensity):
+        """Create music for a specific song section"""
+        section_duration = end_time - start_time
         
-        # Enhanced drum patterns
-        if "Drums" in instruments:
-            self.create_advanced_drums(instruments["Drums"], beat_times, style)
+        # Get beats for this section
+        section_beats = [t for t in features['beats'] if start_time <= t < end_time]
+        if not section_beats:
+            section_beats = np.linspace(start_time, end_time, 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)
+        # Section-specific arrangements
+        if section_name in ["intro", "outro"]:
+            self.create_intro_outro(band, style, section_name, start_time, end_time, section_beats)
+        elif section_name in ["verse", "theme"]:
+            self.create_verse(band, style, start_time, end_time, section_beats, features)
+        elif section_name in ["chorus", "drop", "climax"]:
+            self.create_chorus(band, style, start_time, end_time, section_beats, features)
+        elif section_name in ["bridge", "break", "solo"]:
+            self.create_bridge(band, style, start_time, end_time, section_beats, features)
+        elif section_name in ["build"]:
+            self.create_build(band, style, start_time, end_time, section_beats, features)
+    
+    def create_intro_outro(self, band, style, section_name, start_time, end_time, beats):
+        """Create intro/outro sections"""
+        # Drums - simple pattern
+        if 'drums' in band:
+            for i, beat_time in enumerate(beats):
+                if i % 4 == 0:  # Kick on downbeat
+                    band['drums'].notes.append(self.create_note(36, 80, beat_time, 0.3))
+                if section_name == "intro" and i % 2 == 0:  # Hi-hat in intro
+                    band['drums'].notes.append(self.create_note(42, 60, beat_time, 0.1))
         
-        # 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:
-            self.create_adaptive_melody(melody_instruments[0], y, sr, duration, melody_contour, style)
+        # Bass - simple root notes
+        if 'bass' in band:
+            root_note = 36 if style != "cinematic" else 48
+            for i, beat_time in enumerate(beats[::2]):
+                band['bass'].notes.append(self.create_note(root_note, 70, beat_time, 0.8))
         
-        # 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)
+        # Pad/strings - atmospheric
+        pad_instrument = next((inst for role, inst in band.items() if 'pad' in role or 'string' in role), None)
+        if pad_instrument:
+            chord_notes = self.get_chord_for_section(style, section_name, 0)
+            for note_pitch in chord_notes:
+                pad_instrument.notes.append(self.create_note(note_pitch, 50, start_time, end_time - start_time))
     
-    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_verse(self, band, style, start_time, end_time, beats, features):
+        """Create verse section"""
+        # Full drum pattern
+        if 'drums' in band:
+            for i, beat_time in enumerate(beats):
+                # Kick on 1 and 3
+                if i % 4 in [0, 2]:
+                    band['drums'].notes.append(self.create_note(36, 85, beat_time, 0.3))
+                # Snare on 2 and 4
+                if i % 4 in [1, 3]:
+                    band['drums'].notes.append(self.create_note(38, 80, beat_time, 0.25))
+                # Hi-hats
+                if style in ["pop", "electronic"]:
+                    band['drums'].notes.append(self.create_note(42, 65, beat_time, 0.1))
+        
+        # Bass line
+        if 'bass' in band:
+            bass_line = self.create_bass_line(beats, style)
+            for note in bass_line:
+                band['bass'].notes.append(note)
+        
+        # Melody from audio analysis
+        if 'lead' in band or 'guitar1' in band:
+            lead_instrument = band.get('lead') or band.get('guitar1')
+            if lead_instrument:
+                melody = self.extract_melody_for_section(features['melody_contour'], start_time, end_time)
+                for time, freq in melody:
+                    midi_note = self.freq_to_midi(freq)
+                    if 48 <= midi_note <= 84:
+                        lead_instrument.notes.append(self.create_note(midi_note, 80, time, 0.4))
     
-    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]
+    def create_chorus(self, band, style, start_time, end_time, beats, features):
+        """Create chorus/drop section - more intense"""
+        # Energetic drums
+        if 'drums' in band:
+            for i, beat_time in enumerate(beats):
+                # Stronger kicks
+                if i % 4 in [0, 2]:
+                    band['drums'].notes.append(self.create_note(36, 95, beat_time, 0.4))
+                # Louder snares
+                if i % 4 in [1, 3]:
+                    band['drums'].notes.append(self.create_note(38, 90, beat_time, 0.3))
+                # More hi-hats
+                if style in ["pop", "electronic"]:
+                    band['drums'].notes.append(self.create_note(42, 75, beat_time, 0.15))
+                # Crash cymbal on first beat
+                if i == 0:
+                    band['drums'].notes.append(self.create_note(49, 100, beat_time, 1.0))
+        
+        # More active bass
+        if 'bass' in band:
+            for i, beat_time in enumerate(beats):
+                bass_note = 36 + (i % 4) * 2
+                band['bass'].notes.append(self.create_note(bass_note, 85, beat_time, 0.6))
         
-        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))
+        # All instruments play
+        for role, instrument in band.items():
+            if role not in ['drums', 'bass'] and not instrument.is_drum:
+                chord_notes = self.get_chord_for_section(style, "chorus", 0)
+                for note_pitch in chord_notes:
+                    instrument.notes.append(self.create_note(note_pitch, 70, start_time, end_time - start_time))
     
-    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_bass_line(self, beats, style):
+        """Create melodic bass line"""
+        bass_notes = []
+        if style == "pop":
+            pattern = [36, 38, 41, 43, 41, 38, 36, 35]
+        elif style == "electronic":
+            pattern = [36, 36, 39, 39, 41, 41, 39, 36]
+        elif style == "rock":
+            pattern = [36, 38, 36, 41, 36, 38, 36, 43]
+        else:  # cinematic
+            pattern = [36, 39, 43, 46, 43, 39, 36, 34]
+        
+        for i, beat_time in enumerate(beats[::2]):  # Every other beat
+            note_pitch = pattern[i % len(pattern)]
+            bass_notes.append(self.create_note(note_pitch, 80, beat_time, 0.9))
+        
+        return bass_notes
     
-    def create_harmonic_background(self, instrument, beat_times, style):
-        """Create chordal harmony"""
+    def extract_melody_for_section(self, melody_contour, start_time, end_time):
+        """Extract melody notes for a specific section"""
+        section_melody = []
+        for time, freq in melody_contour:
+            if start_time <= time < end_time:
+                section_melody.append((time, freq))
+        
+        # If no melody detected, create one
+        if not section_melody:
+            section_duration = end_time - start_time
+            for i in range(8):
+                time = start_time + (i / 8) * section_duration
+                freq = 440 * (2 ** (i / 12))  # Rising pattern
+                section_melody.append((time, freq))
+        
+        return section_melody
+    
+    def get_chord_for_section(self, style, section_name, section_idx):
+        """Get appropriate chords for section"""
         if style == "pop":
             chords = [[60, 64, 67], [65, 69, 72], [67, 71, 74], [62, 65, 69]]  # C, F, G, Am
         elif style == "electronic":
@@ -232,10 +311,7 @@ class AdvancedMP3Humanizer:
         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))
+        return chords[section_idx % len(chords)]
     
     def freq_to_midi(self, frequency):
         """Convert frequency to MIDI note number"""
@@ -250,58 +326,61 @@ class AdvancedMP3Humanizer:
             end=start + duration
         )
     
-    def advanced_humanization(self, midi, intensity):
-        """Advanced humanization with more natural variations"""
+    def apply_complete_humanization(self, midi, intensity):
+        """Apply realistic humanization to entire song"""
         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
+                timing_variance = 0.01  # Drums are tighter
+                velocity_variance = 8
+            elif any(role in instrument.name.lower() for role in ['bass', 'pad', 'string']):
+                timing_variance = 0.02  # Background instruments
+                velocity_variance = 10
+            else:
+                timing_variance = 0.03  # Lead instruments have more feel
+                velocity_variance = 15
             
             for note in instrument.notes:
-                # 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)
+                # Timing variations
+                note.start += np.random.normal(0, timing_variance * intensity)
+                note.start = max(0, note.start)
                 
-                # 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)))
+                # Velocity variations
+                vel_change = int(np.random.normal(0, velocity_variance * intensity))
+                note.velocity = max(30, min(127, note.velocity + vel_change))
                 
                 # Duration variations (except drums)
                 if not instrument.is_drum:
-                    dur_variation = np.random.normal(0, 0.08 * intensity * humanization_factor)
-                    note.end = max(note.start + 0.1, note.end + dur_variation)
+                    dur_change = np.random.normal(0, 0.05 * intensity)
+                    note.end = max(note.start + 0.1, note.end + dur_change)
 
-def convert_mp3(input_mp3, style, intensity):
-    """Main conversion function"""
+def create_complete_song(input_mp3, style, intensity):
+    """Main function to create complete song"""
     if input_mp3 is None:
         return None, "Please upload an MP3 file"
     
-    converter = AdvancedMP3Humanizer()
+    humanizer = CompleteSongHumanizer()
     
     try:
-        # Convert to humanized MP3 with better sounds
-        audio_data, sr = converter.mp3_to_humanized_mp3(input_mp3, style, intensity)
+        # Create complete humanized song
+        audio_data, sr = humanizer.create_complete_song(input_mp3, style, intensity)
         
-        # Save as temporary MP3 file
-        output_path = tempfile.mktemp(suffix='_humanized.mp3')
+        # Save as MP3
+        output_path = tempfile.mktemp(suffix='_complete_song.mp3')
         sf.write(output_path, audio_data, sr)
         
-        return output_path, "✅ Conversion successful! Your humanized song is ready below."
+        return output_path, "🎵 Complete song created! Your humanized masterpiece is ready!"
         
     except Exception as e:
         return None, f"❌ Error: {str(e)}"
 
-# Enhanced interface
-with gr.Blocks(theme=gr.themes.Soft(), title="Advanced MP3 Humanizer") as demo:
+# Professional interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Complete Song Humanizer") as demo:
     gr.Markdown("""
-    # 🎵 Advanced MP3 Humanizer
-    **Transform AI Music into Realistic Human Performances**
+    # 🎵 Complete Song Humanizer
+    **Transform AI Music into Full, Professional Human Performances**
     
-    *Now with better instrument sounds and realistic musical arrangements!*
+    *Creates complete songs with verses, choruses, and full band arrangements*
     """)
     
     with gr.Row():
@@ -313,67 +392,68 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Advanced MP3 Humanizer") as demo:
                 label="Upload MP3 File"
             )
             
-            gr.Markdown("### 2. Choose Music Style")
+            gr.Markdown("### 2. Choose Song Style")
             style = gr.Radio(
                 ["pop", "electronic", "rock", "cinematic"],
                 value="pop",
-                label="Select Style",
-                info="Each style uses different instruments and patterns"
+                label="Music Genre",
+                info="Each style creates different band arrangements"
             )
             
             intensity = gr.Slider(
-                0.1, 1.0, value=0.7,
+                0.1, 1.0, value=0.8,
                 label="Human Feel Intensity",
-                info="Higher = more natural human variations"
+                info="How natural and human-like the performance sounds"
             )
             
-            convert_btn = gr.Button(
-                "🎹 Create Human Version",
+            create_btn = gr.Button(
+                "🎹 Create Complete Song",
                 variant="primary",
                 size="lg"
             )
         
         with gr.Column(scale=1):
-            gr.Markdown("### 3. Your Humanized Song")
+            gr.Markdown("### 3. Your Complete Song")
             output_audio = gr.Audio(
-                label="Enhanced Human Version",
+                label="Your Humanized Masterpiece",
                 type="filepath",
                 interactive=False
             )
             
             status = gr.Textbox(
-                label="Status",
+                label="Creation Status",
                 interactive=False
             )
     
-    # Enhanced instructions
-    with gr.Accordion("🎸 What's New in This Version", open=True):
+    # Song details
+    with gr.Accordion("🎼 What You're Getting", open=True):
         gr.Markdown("""
-        **Major Improvements:**
+        **Each song includes:**
+        
+        **🎵 Complete Song Structure:**
+        - Intro, Verses, Choruses, Bridge, Outro
+        - Professional arrangement with buildup and climax
+        - Dynamic changes between sections
         
-        🥁 **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
+        **🎸 Full Band Arrangement:**
+        - **Pop**: Drums, Bass, Guitar, Piano, Strings, Synth (6 instruments)
+        - **Electronic**: EDM Drums, Synth Bass, Lead, Pad, FX, Electric Piano (6 instruments)  
+        - **Rock**: Rock Drums, Bass, 2 Guitars, Keys, Strings (6 instruments)
+        - **Cinematic**: Orchestral Drums, 2 String sections, Brass, Woodwinds, Harp (6 instruments)
         
-        **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
+        **🎛️ Professional Production:**
+        - Realistic human timing variations
+        - Dynamic velocity changes
+        - Section-specific arrangements
+        - Melodic development
+        - Harmonic progression
         
-        **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!
+        **⏱️ Processing Time:** ~15-30 seconds for a complete song
         """)
     
-    # Conversion process
-    convert_btn.click(
-        fn=convert_mp3,
+    # Creation process
+    create_btn.click(
+        fn=create_complete_song,
         inputs=[input_audio, style, intensity],
         outputs=[output_audio, status]
     )