Update app.py

full product updates

app.py

@@ -32,6 +32,12 @@ if device != "cuda":
     sys.exit(1)
 print(f"CUDA is available. Using GPU: {torch.cuda.get_device_name(0)}")
 
+# Pre-run memory cleanup
+torch.cuda.empty_cache()
+gc.collect()
+torch.cuda.ipc_collect()
+torch.cuda.synchronize()
+
 # 2) LOAD MUSICGEN INTO VRAM
 try:
     print("Loading MusicGen medium model into VRAM...")
@@ -42,7 +48,7 @@ try:
         sys.exit(1)
     musicgen_model = MusicGen.get_pretrained(local_model_path, device=device)
     musicgen_model.set_generation_params(
-        duration=20,  # Default chunk duration
+        duration=10,  # Default chunk duration
         two_step_cfg=False  # Disable two-step CFG for stability
     )
 except Exception as e:
@@ -59,286 +65,265 @@ def print_resource_usage(stage: str):
     print("---------------")
 
 # Check available GPU memory
-def check_vram_availability(required_gb=6.0):
+def check_vram_availability(required_gb=3.5):
     total_vram = torch.cuda.get_device_properties(0).total_memory / (1024**3)
     allocated_vram = torch.cuda.memory_allocated() / (1024**3)
     available_vram = total_vram - allocated_vram
     if available_vram < required_gb:
-        print(f"WARNING: Low VRAM available ({available_vram:.2f} GB). Consider reducing total_duration or num_variations.")
+        print(f"WARNING: Low VRAM available ({available_vram:.2f} GB). Reduce total_duration or chunk_duration.")
     return available_vram >= required_gb
 
 # 4) GENRE PROMPT FUNCTIONS
-def set_red_hot_chili_peppers_prompt(bpm):
-    rhythm = "strong rhythmic steps" if bpm > 120 else "groovy rhythmic flow"
-    return f"Funk rock with groovy basslines, syncopated guitar riffs, energetic drums, and a Red Hot Chili Peppers-inspired vibe with dynamic vocal energy and funky breakdowns, {rhythm} at {bpm} BPM."
-
-def set_nirvana_grunge_prompt(bpm):
-    rhythm = "intense rhythmic steps" if bpm > 120 else "grungy rhythmic pulse"
-    return f"Grunge with raw distorted guitar riffs, heavy drums, melodic basslines, and a Nirvana-inspired angst-filled sound with quiet-loud dynamics, {rhythm} at {bpm} BPM."
-
-def set_pearl_jam_grunge_prompt(bpm):
-    rhythm = "soulful rhythmic steps" if bpm > 120 else "driving rhythmic flow"
-    return f"Grunge with soulful guitar leads, driving rhythms, deep bass, and a Pearl Jam-inspired emotional intensity with soaring choruses, {rhythm} at {bpm} BPM."
-
-def set_soundgarden_grunge_prompt(bpm):
-    rhythm = "heavy rhythmic steps" if bpm > 120 else "sludgy rhythmic groove"
-    return f"Grunge with heavy, sludgy guitar riffs, complex drum patterns, and a Soundgarden-inspired dark, psychedelic edge with powerful vocals, {rhythm} at {bpm} BPM."
-
-def set_foo_fighters_prompt(bpm):
+def set_red_hot_chili_peppers_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("strong rhythmic steps" if bpm > 120 else "groovy rhythmic flow")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", groovy basslines"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", syncopated guitar riffs"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Funk rock{bass}{guitar}{drum}{synth}{vocal}, Red Hot Chili Peppers-inspired vibe with dynamic energy and funky breakdowns, {rhythm} at {bpm} BPM."
+
+def set_nirvana_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("intense rhythmic steps" if bpm > 120 else "grungy rhythmic pulse")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", melodic basslines"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", raw distorted guitar riffs"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Grunge{bass}{guitar}{drum}{synth}{vocal}, Nirvana-inspired angst-filled sound with quiet-loud dynamics, {rhythm} at {bpm} BPM."
+
+def set_pearl_jam_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("soulful rhythmic steps" if bpm > 120 else "driving rhythmic flow")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", deep bass"
+    guitar = f", {guitar_style} guitar leads" if guitar_style != "none" else ", soulful guitar leads"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Grunge{bass}{guitar}{drum}{synth}{vocal}, Pearl Jam-inspired emotional intensity with soaring choruses, {rhythm} at {bpm} BPM."
+
+def set_soundgarden_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("heavy rhythmic steps" if bpm > 120 else "sludgy rhythmic groove")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ""
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", heavy sludgy guitar riffs"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Grunge{bass}{guitar}{drum}{synth}{vocal}, Soundgarden-inspired dark, psychedelic edge with powerful vocals, {rhythm} at {bpm} BPM."
+
+def set_foo_fighters_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
     styles = ["anthemic", "gritty", "melodic", "fast-paced", "driving"]
     tempos = ["upbeat", "mid-tempo", "high-energy"]
     moods = ["energetic", "introspective", "rebellious", "uplifting"]
     style = random.choice(styles)
     tempo = random.choice(tempos)
     mood = random.choice(moods)
-    rhythm = "powerful rhythmic steps" if bpm > 120 else "catchy rhythmic groove"
-    return f"Alternative rock with {style} guitar riffs, {tempo} drums, melodic hooks, and a Foo Fighters-inspired {mood} vibe with powerful choruses, {rhythm} at {bpm} BPM."
-
-def set_smashing_pumpkins_prompt(bpm):
-    rhythm = "dynamic rhythmic steps" if bpm > 120 else "dreamy rhythmic flow"
-    return f"Alternative rock with dreamy guitar textures, heavy distortion, dynamic drums, and a Smashing Pumpkins-inspired blend of melancholy and aggression, {rhythm} at {bpm} BPM."
-
-def set_radiohead_prompt(bpm):
-    rhythm = "complex rhythmic steps" if bpm > 120 else "intricate rhythmic pulse"
-    return f"Experimental rock with atmospheric synths, intricate guitar layers, complex rhythms, and a Radiohead-inspired blend of introspective and innovative soundscapes, {rhythm} at {bpm} BPM."
-
-def set_classic_rock_prompt(bpm):
-    rhythm = "bluesy rhythmic steps" if bpm > 120 else "steady rhythmic groove"
-    return f"Classic rock with bluesy electric guitars, steady drums, groovy bass, and a Led Zeppelin-inspired raw energy with dynamic solos, {rhythm} at {bpm} BPM."
-
-def set_alternative_rock_prompt(bpm):
-    rhythm = "quirky rhythmic steps" if bpm > 120 else "energetic rhythmic flow"
-    return f"Alternative rock with distorted guitar riffs, punchy drums, melodic basslines, and a Pixies-inspired quirky, energetic vibe, {rhythm} at {bpm} BPM."
-
-def set_post_punk_prompt(bpm):
-    rhythm = "sharp rhythmic steps" if bpm > 120 else "moody rhythmic pulse"
-    return f"Post-punk with jangly guitars, driving basslines, sharp drums, and a Joy Division-inspired moody, atmospheric sound, {rhythm} at {bpm} BPM."
-
-def set_indie_rock_prompt(bpm):
-    rhythm = "catchy rhythmic steps" if bpm > 120 else "jangly rhythmic flow"
-    return f"Indie rock with jangly guitars, heartfelt vocals, steady drums, and an Arctic Monkeys-inspired blend of witty lyrics and catchy riffs, {rhythm} at {bpm} BPM."
-
-def set_funk_rock_prompt(bpm):
-    rhythm = "aggressive rhythmic steps" if bpm > 120 else "funky rhythmic groove"
-    return f"Funk rock with slap bass, funky guitar chords, upbeat drums, and a Rage Against the Machine-inspired mix of groove and aggression, {rhythm} at {bpm} BPM."
-
-def set_detroit_techno_prompt(bpm):
-    rhythm = "pulsing rhythmic steps" if bpm > 120 else "deep rhythmic groove"
-    return f"Detroit techno with deep pulsing synths, driving basslines, crisp hi-hats, and a Juan Atkins-inspired rhythmic groove, {rhythm} at {bpm} BPM."
-
-def set_deep_house_prompt(bpm):
-    rhythm = "soulful rhythmic steps" if bpm > 120 else "laid-back rhythmic flow"
-    return f"Deep house with warm analog synth chords, soulful vocal chops, deep basslines, and a Larry Heard-inspired laid-back groove, {rhythm} at {bpm} BPM."
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("powerful rhythmic steps" if bpm > 120 else "catchy rhythmic groove")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ""
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", {style} guitar riffs"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Alternative rock{bass}{guitar}{drum}{synth}{vocal}, Foo Fighters-inspired {mood} vibe with powerful choruses, {rhythm} at {bpm} BPM."
+
+def set_smashing_pumpkins_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("dynamic rhythmic steps" if bpm > 120 else "dreamy rhythmic flow")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ""
+    guitar = f", {guitar_style} guitar textures" if guitar_style != "none" else ", dreamy guitar textures"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Alternative rock{bass}{guitar}{drum}{synth}{vocal}, Smashing Pumpkins-inspired blend of melancholy and aggression, {rhythm} at {bpm} BPM."
+
+def set_radiohead_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("complex rhythmic steps" if bpm > 120 else "intricate rhythmic pulse")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ", atmospheric synths"
+    bass = f", {bass_style}" if bass_style != "none" else ""
+    guitar = f", {guitar_style} guitar layers" if guitar_style != "none" else ", intricate guitar layers"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Experimental rock{bass}{guitar}{drum}{synth}{vocal}, Radiohead-inspired blend of introspective and innovative soundscapes, {rhythm} at {bpm} BPM."
+
+def set_classic_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("bluesy rhythmic steps" if bpm > 120 else "steady rhythmic groove")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", groovy bass"
+    guitar = f", {guitar_style} electric guitars" if guitar_style != "none" else ", bluesy electric guitars"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Classic rock{bass}{guitar}{drum}{synth}{vocal}, Led Zeppelin-inspired raw energy with dynamic solos, {rhythm} at {bpm} BPM."
+
+def set_alternative_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("quirky rhythmic steps" if bpm > 120 else "energetic rhythmic flow")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", melodic basslines"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", distorted guitar riffs"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Alternative rock{bass}{guitar}{drum}{synth}{vocal}, Pixies-inspired quirky, energetic vibe, {rhythm} at {bpm} BPM."
+
+def set_post_punk_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("sharp rhythmic steps" if bpm > 120 else "moody rhythmic pulse")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", driving basslines"
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ", jangly guitars"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Post-punk{bass}{guitar}{drum}{synth}{vocal}, Joy Division-inspired moody, atmospheric sound, {rhythm} at {bpm} BPM."
+
+def set_indie_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("catchy rhythmic steps" if bpm > 120 else "jangly rhythmic flow")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ""
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ", jangly guitars"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ", heartfelt vocals"
+    return f"Indie rock{bass}{guitar}{drum}{synth}{vocal}, Arctic Monkeys-inspired blend of witty lyrics and catchy riffs, {rhythm} at {bpm} BPM."
+
+def set_funk_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("aggressive rhythmic steps" if bpm > 120 else "funky rhythmic groove")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", slap bass"
+    guitar = f", {guitar_style} guitar chords" if guitar_style != "none" else ", funky guitar chords"
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Funk rock{bass}{guitar}{drum}{synth}{vocal}, Rage Against the Machine-inspired mix of groove and aggression, {rhythm} at {bpm} BPM."
+
+def set_detroit_techno_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("pulsing rhythmic steps" if bpm > 120 else "deep rhythmic groove")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ", crisp hi-hats"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ", deep pulsing synths"
+    bass = f", {bass_style}" if bass_style != "none" else ", driving basslines"
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ""
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ""
+    return f"Detroit techno{bass}{guitar}{drum}{synth}{vocal}, Juan Atkins-inspired rhythmic groove, {rhythm} at {bpm} BPM."
+
+def set_deep_house_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("soulful rhythmic steps" if bpm > 120 else "laid-back rhythmic flow")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ""
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ", warm analog synth chords"
+    bass = f", {bass_style}" if bass_style != "none" else ", deep basslines"
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ""
+    vocal = f", {vocal_presence}" if vocal_presence != "none" else ", soulful vocal chops"
+    return f"Deep house{bass}{guitar}{drum}{synth}{vocal}, Larry Heard-inspired laid-back groove, {rhythm} at {bpm} BPM."
 
 # 5) AUDIO PROCESSING FUNCTIONS
-def apply_chorus(segment):
-    delayed = segment - 6
-    delayed = delayed.set_frame_rate(segment.frame_rate)
-    return segment.overlay(delayed, position=20)
-
 def apply_eq(segment):
     segment = segment.low_pass_filter(8000)
     segment = segment.high_pass_filter(80)
     return segment
 
-def apply_limiter(segment, max_db=-6.0):
-    if segment.dBFS > max_db:
-        segment = segment - (segment.dBFS - max_db)
-    return segment
-
-def apply_final_gain(segment, target_db=-18.0):
-    gain_adjustment = target_db - segment.dBFS
-    return segment + gain_adjustment
-
-def apply_fade(segment, fade_in_duration=2000, fade_out_duration=2000):
+def apply_fade(segment, fade_in_duration=1000, fade_out_duration=1000):
     segment = segment.fade_in(fade_in_duration)
     segment = segment.fade_out(fade_out_duration)
     return segment
 
 # 6) GENERATION & I/O FUNCTIONS
-def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p: float, temperature: float, total_duration: int, crossfade_duration: int, variation_crossfade_duration: int, num_variations: int, chunk_count: int, use_chunks: bool, bpm: int):
+def generate_music(instrumental_prompt: str, cfg_scale: float, total_duration: int, chunk_duration: int, crossfade_duration: int, bpm: int, drum_beat: str, synthesizer: str, rhythmic_steps: str, bass_style: str, guitar_style: str, vocal_presence: str):
     global musicgen_model
     if not instrumental_prompt.strip():
         return None, "⚠️ Please enter a valid instrumental prompt!"
     try:
         start_time = time.time()
-        total_duration = min(max(total_duration, 10), 90)
+        total_duration = min(max(total_duration, 5), 30)
+        chunk_duration = min(max(chunk_duration, 5), 15)
+        num_chunks = max(1, total_duration // chunk_duration)
+        chunk_duration = total_duration / num_chunks
+        overlap_duration = min(1.0, crossfade_duration / 1000.0)
+        generation_duration = chunk_duration + overlap_duration
         sample_rate = musicgen_model.sample_rate
-        output_files = []
-        variation_segments = []
-
-        # Check VRAM availability
-        if not check_vram_availability(required_gb=6.0):
-            return None, "⚠️ Insufficient VRAM for generation. Reduce total_duration or num_variations."
-
-        # Adjust temperature based on BPM for energy
-        adjusted_temperature = temperature + (bpm - 120) / 600.0  # Scale temperature slightly
-        adjusted_temperature = min(max(adjusted_temperature, 0.1), 2.0)
-
-        for var in range(num_variations):
-            print(f"Generating variation {var+1}/{num_variations}...")
-            seed = 42 + var  # Use different seeds for variations
-            torch.manual_seed(seed)
-            np.random.seed(seed)
-
-            if use_chunks:
-                # Chunked generation
-                num_chunks = max(1, min(chunk_count, total_duration // 20))  # Cap at 20 seconds per chunk
-                chunk_duration = min(total_duration / num_chunks, 20)  # Max 20 seconds
-                overlap_duration = min(1.0, crossfade_duration / 1000.0)
-                generation_duration = chunk_duration + overlap_duration
-                audio_chunks = []
-
-                for i in range(num_chunks):
-                    chunk_prompt = f"{instrumental_prompt}, at {bpm} BPM"
-                    print(f"Generating chunk {i+1}/{num_chunks} for variation {var+1} on GPU (prompt: {chunk_prompt})...")
-                    musicgen_model.set_generation_params(
-                        duration=generation_duration,
-                        use_sampling=True,
-                        top_k=top_k,
-                        top_p=top_p,
-                        temperature=adjusted_temperature,
-                        cfg_coef=cfg_scale
-                    )
-
-                    print_resource_usage(f"Before Chunk {i+1} Generation (Variation {var+1})")
-
-                    with torch.no_grad():
-                        with autocast():
-                            audio_chunk = musicgen_model.generate([chunk_prompt], progress=True)[0]
-
-                    audio_chunk = audio_chunk.cpu().to(dtype=torch.float32)
-                    if audio_chunk.dim() == 1:
-                        audio_chunk = torch.stack([audio_chunk, audio_chunk], dim=0)
-                    elif audio_chunk.dim() == 2 and audio_chunk.shape[0] == 1:
-                        audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
-                    elif audio_chunk.dim() == 2 and audio_chunk.shape[0] != 2:
-                        audio_chunk = audio_chunk[:1, :]
-                        audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
-                    elif audio_chunk.dim() > 2:
-                        audio_chunk = audio_chunk.view(2, -1)
-
-                    if audio_chunk.shape[0] != 2:
-                        raise ValueError(f"Expected stereo audio with shape (2, samples), got shape {audio_chunk.shape}")
-
-                    temp_wav_path = f"temp_chunk_{var}_{i}.wav"
-                    chunk_path = f"chunk_{var}_{i}.mp3"
-                    torchaudio.save(temp_wav_path, audio_chunk, sample_rate, bits_per_sample=24)
-                    segment = AudioSegment.from_wav(temp_wav_path)
-                    segment.export(chunk_path, format="mp3", bitrate="320k")
-                    os.remove(temp_wav_path)
-                    audio_chunks.append(chunk_path)
-
-                    torch.cuda.empty_cache()
-                    gc.collect()
-                    torch.cuda.synchronize()
-                    time.sleep(0.5)
-                    print_resource_usage(f"After Chunk {i+1} Generation (Variation {var+1})")
-
-                print(f"Combining audio chunks for variation {var+1}...")
-                final_segment = AudioSegment.from_mp3(audio_chunks[0])
-                for i in range(1, len(audio_chunks)):
-                    next_segment = AudioSegment.from_mp3(audio_chunks[i])
-                    next_segment = next_segment + 1
-                    final_segment = final_segment.append(next_segment, crossfade=crossfade_duration)
-
-                final_segment = final_segment[:total_duration * 1000]
-                variation_segments.append(final_segment)
-
-                for chunk_path in audio_chunks:
-                    os.remove(chunk_path)
-            else:
-                # Single-shot generation
-                print(f"Generating full track for variation {var+1} on GPU (prompt: {instrumental_prompt})...")
-                musicgen_model.set_generation_params(
-                    duration=total_duration,
-                    use_sampling=True,
-                    top_k=top_k,
-                    top_p=top_p,
-                    temperature=adjusted_temperature,
-                    cfg_coef=cfg_scale
-                )
-
-                print_resource_usage(f"Before Full Track Generation (Variation {var+1})")
-
-                with torch.no_grad():
-                    with autocast():
-                        audio_chunk = musicgen_model.generate([f"{instrumental_prompt}, at {bpm} BPM"], progress=True)[0]
-
-                audio_chunk = audio_chunk.cpu().to(dtype=torch.float32)
-                if audio_chunk.dim() == 1:
-                    audio_chunk = torch.stack([audio_chunk, audio_chunk], dim=0)
-                elif audio_chunk.dim() == 2 and audio_chunk.shape[0] == 1:
-                    audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
-                elif audio_chunk.dim() == 2 and audio_chunk.shape[0] != 2:
-                    audio_chunk = audio_chunk[:1, :]
-                    audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
-                elif audio_chunk.dim() > 2:
-                    audio_chunk = audio_chunk.view(2, -1)
-
-                if audio_chunk.shape[0] != 2:
-                    raise ValueError(f"Expected stereo audio with shape (2, samples), got shape {audio_chunk.shape}")
-
-                temp_wav_path = f"temp_full_{var}.wav"
-                torchaudio.save(temp_wav_path, audio_chunk, sample_rate, bits_per_sample=24)
-                final_segment = AudioSegment.from_wav(temp_wav_path)
-                os.remove(temp_wav_path)
-                variation_segments.append(final_segment)
-
-                torch.cuda.empty_cache()
-                gc.collect()
-                torch.cuda.synchronize()
-                time.sleep(0.5)
-                print_resource_usage(f"After Full Track Generation (Variation {var+1})")
-
-        # Combine variations with crossfade
-        print("Combining variations with crossfade...")
-        combined_segment = variation_segments[0]
-        for i in range(1, len(variation_segments)):
-            next_segment = variation_segments[i]
+        audio_segments = []
+
+        if not check_vram_availability(required_gb=3.5):
+            return None, "⚠️ Insufficient VRAM for generation. Reduce total_duration or chunk_duration."
+
+        print("Generating audio...")
+        seed = 42
+        torch.manual_seed(seed)
+        np.random.seed(seed)
+
+        for i in range(num_chunks):
+            chunk_prompt = instrumental_prompt
+            print(f"Generating chunk {i+1}/{num_chunks} on GPU (prompt: {chunk_prompt})...")
+            musicgen_model.set_generation_params(
+                duration=generation_duration,
+                use_sampling=True,
+                top_k=250,
+                top_p=0.9,
+                temperature=1.0,
+                cfg_coef=cfg_scale
+            )
+
+            print_resource_usage(f"Before Chunk {i+1} Generation")
+
+            with torch.no_grad():
+                with autocast():
+                    audio_chunk = musicgen_model.generate([chunk_prompt], progress=True)[0]
+
+            audio_chunk = audio_chunk.cpu().to(dtype=torch.float32)
+            if audio_chunk.dim() == 1:
+                audio_chunk = torch.stack([audio_chunk, audio_chunk], dim=0)
+            elif audio_chunk.dim() == 2 and audio_chunk.shape[0] == 1:
+                audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
+            elif audio_chunk.dim() == 2 and audio_chunk.shape[0] != 2:
+                audio_chunk = audio_chunk[:1, :]
+                audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
+            elif audio_chunk.dim() > 2:
+                audio_chunk = audio_chunk.view(2, -1)
+
+            if audio_chunk.shape[0] != 2:
+                raise ValueError(f"Expected stereo audio with shape (2, samples), got shape {audio_chunk.shape}")
+
+            temp_wav_path = f"temp_chunk_{i}.wav"
+            torchaudio.save(temp_wav_path, audio_chunk, sample_rate, bits_per_sample=24)
+            segment = AudioSegment.from_wav(temp_wav_path)
+            os.remove(temp_wav_path)
+            audio_segments.append(segment)
+
+            torch.cuda.empty_cache()
+            gc.collect()
+            torch.cuda.ipc_collect()
+            torch.cuda.synchronize()
+            time.sleep(0.5)
+            print_resource_usage(f"After Chunk {i+1} Generation")
+
+        print("Combining audio chunks...")
+        final_segment = audio_segments[0]
+        for i in range(1, len(audio_segments)):
+            next_segment = audio_segments[i]
             next_segment = next_segment + 1
-            combined_segment = combined_segment.append(next_segment, crossfade=variation_crossfade_duration)
+            final_segment = final_segment.append(next_segment, crossfade=crossfade_duration)
+
+        final_segment = final_segment[:total_duration * 1000]
 
-        # Post-process combined track
         print("Post-processing final track...")
-        combined_segment = apply_eq(combined_segment)
-        combined_segment = apply_chorus(combined_segment)
-        combined_segment = apply_limiter(combined_segment, max_db=-6.0)
-        combined_segment = combined_segment.normalize(headroom=-9.0)
-        combined_segment = apply_final_gain(combined_segment, target_db=-18.0)
+        final_segment = apply_eq(final_segment)
+        final_segment = final_segment.normalize(headroom=-9.0)
+        final_segment = apply_fade(final_segment)
 
         mp3_path = "output_cleaned.mp3"
-        combined_segment.export(
+        final_segment.export(
             mp3_path,
             format="mp3",
-            bitrate="320k",
+            bitrate="128k",
             tags={"title": "GhostAI Instrumental", "artist": "GhostAI"}
         )
         print(f"Saved final audio to {mp3_path}")
-        output_files.append(mp3_path)
 
         print_resource_usage("After Final Generation")
         print(f"Total Generation Time: {time.time() - start_time:.2f} seconds")
 
-        # Return the combined track for Gradio display
-        return mp3_path, f"✅ Done! Generated {num_variations} variations."
+        return mp3_path, "✅ Done! Generated audio."
     except Exception as e:
         return None, f"❌ Generation failed: {e}"
     finally:
         torch.cuda.empty_cache()
         gc.collect()
+        torch.cuda.ipc_collect()
         torch.cuda.synchronize()
 
-# Function to toggle interactivity of chunk-related sliders
-def toggle_chunk_interactivity(use_chunks):
-    return (
-        gr.update(interactive=use_chunks),  # crossfade_duration
-        gr.update(interactive=use_chunks),  # variation_crossfade_duration
-        gr.update(interactive=use_chunks)   # chunk_count
-    )
-
+# Function to clear inputs
 def clear_inputs():
-    return "", 3.0, 250, 0.9, 1.0, 20, 1000, 1000, 1, 2, True, 120
+    return "", 3.0, 10, 10, 1000, 120, "none", "none", "none", "none", "none", "none"
 
 # 7) CUSTOM CSS
 css = """
@@ -449,74 +434,29 @@ with gr.Blocks(css=css) as demo:
             step=0.1,
             info="Higher values make the instrumental more closely follow the prompt."
         )
-        top_k = gr.Slider(
-            label="Top-K Sampling",
-            minimum=10,
-            maximum=500,
-            value=250,
-            step=10,
-            info="Limits sampling to the top k most likely tokens."
-        )
-        top_p = gr.Slider(
-            label="Top-P Sampling",
-            minimum=0.0,
-            maximum=1.0,
-            value=0.9,
-            step=0.05,
-            info="Keeps tokens with cumulative probability above p."
-        )
-        temperature = gr.Slider(
-            label="Temperature",
-            minimum=0.1,
-            maximum=2.0,
-            value=1.0,
-            step=0.1,
-            info="Controls randomness. Higher values make output more diverse."
-        )
         total_duration = gr.Slider(
             label="Total Duration (seconds)",
-            minimum=10,
-            maximum=90,
-            value=20,
+            minimum=5,
+            maximum=30,
+            value=10,
             step=1,
-            info="Total duration of the track (10 to 90 seconds)."
+            info="Total duration of the track (5 to 30 seconds)."
         )
-        crossfade_duration = gr.Slider(
-            label="Chunk Crossfade Duration (ms)",
-            minimum=100,
-            maximum=2000,
-            value=1000,
-            step=100,
-            info="Crossfade duration between chunks (only used if chunking is enabled)."
+        chunk_duration = gr.Slider(
+            label="Chunk Duration (seconds)",
+            minimum=5,
+            maximum=15,
+            value=10,
+            step=1,
+            info="Duration of each chunk to render (5 to 15 seconds)."
         )
-        variation_crossfade_duration = gr.Slider(
-            label="Variation Crossfade Duration (ms)",
+        crossfade_duration = gr.Slider(
+            label="Crossfade Duration (ms)",
             minimum=100,
             maximum=2000,
             value=1000,
             step=100,
-            info="Crossfade duration between variations."
-        )
-        num_variations = gr.Slider(
-            label="Number of Variations",
-            minimum=1,
-            maximum=4,
-            value=1,
-            step=1,
-            info="Number of different versions to generate with varying random seeds."
-        )
-        chunk_count = gr.Slider(
-            label="Chunk Count",
-            minimum=1,
-            maximum=8,
-            value=2,
-            step=1,
-            info="Number of chunks to split the track into (only used if chunking is enabled, max 20 seconds per chunk)."
-        )
-        use_chunks = gr.Checkbox(
-            label="Generate in Chunks",
-            value=True,
-            info="Enable to generate in chunks (safer for GPU memory). Disable for single-shot generation (higher VRAM usage)."
+            info="Crossfade duration between chunks."
         )
         bpm = gr.Slider(
             label="Tempo (BPM)",
@@ -526,6 +466,42 @@ with gr.Blocks(css=css) as demo:
             step=1,
             info="Beats per minute to influence the track's tempo."
         )
+        drum_beat = gr.Dropdown(
+            label="Drum Beat",
+            choices=["none", "standard rock", "funk groove", "techno kick", "jazz swing"],
+            value="none",
+            info="Select a drum beat style to influence the rhythm."
+        )
+        synthesizer = gr.Dropdown(
+            label="Synthesizer",
+            choices=["none", "analog synth", "digital pad", "arpeggiated synth"],
+            value="none",
+            info="Select a synthesizer style to add electronic accents."
+        )
+        rhythmic_steps = gr.Dropdown(
+            label="Rhythmic Steps",
+            choices=["none", "syncopated steps", "steady steps", "complex steps"],
+            value="none",
+            info="Select a rhythmic step style to enhance the beat."
+        )
+        bass_style = gr.Dropdown(
+            label="Bass Style",
+            choices=["none", "slap bass", "deep bass", "melodic bass"],
+            value="none",
+            info="Select a bass style to shape the low end."
+        )
+        guitar_style = gr.Dropdown(
+            label="Guitar Style",
+            choices=["none", "distorted", "clean", "jangle"],
+            value="none",
+            info="Select a guitar style to define the riffs."
+        )
+        vocal_presence = gr.Dropdown(
+            label="Vocal Presence",
+            choices=["none", "background vocals", "vocal chops"],
+            value="none",
+            info="Select a vocal style to add vocal elements."
+        )
         with gr.Row(elem_classes="action-buttons"):
             gen_btn = gr.Button("Generate Music")
             clr_btn = gr.Button("Clear Inputs")
@@ -534,37 +510,29 @@ with gr.Blocks(css=css) as demo:
         out_audio = gr.Audio(label="Generated Stereo Instrumental Track", type="filepath")
         status = gr.Textbox(label="Status", interactive=False)
     
-    # Toggle chunk-related sliders' interactivity
-    use_chunks.change(
-        fn=toggle_chunk_interactivity,
-        inputs=use_chunks,
-        outputs=[crossfade_duration, variation_crossfade_duration, chunk_count]
-    )
-
-    # Bind genre buttons with BPM
-    rhcp_btn.click(set_red_hot_chili_peppers_prompt, inputs=bpm, outputs=instrumental_prompt)
-    nirvana_btn.click(set_nirvana_grunge_prompt, inputs=bpm, outputs=instrumental_prompt)
-    pearl_jam_btn.click(set_pearl_jam_grunge_prompt, inputs=bpm, outputs=instrumental_prompt)
-    soundgarden_btn.click(set_soundgarden_grunge_prompt, inputs=bpm, outputs=instrumental_prompt)
-    foo_fighters_btn.click(set_foo_fighters_prompt, inputs=bpm, outputs=instrumental_prompt)
-    smashing_pumpkins_btn.click(set_smashing_pumpkins_prompt, inputs=bpm, outputs=instrumental_prompt)
-    radiohead_btn.click(set_radiohead_prompt, inputs=bpm, outputs=instrumental_prompt)
-    classic_rock_btn.click(set_classic_rock_prompt, inputs=bpm, outputs=instrumental_prompt)
-    alternative_rock_btn.click(set_alternative_rock_prompt, inputs=bpm, outputs=instrumental_prompt)
-    post_punk_btn.click(set_post_punk_prompt, inputs=bpm, outputs=instrumental_prompt)
-    indie_rock_btn.click(set_indie_rock_prompt, inputs=bpm, outputs=instrumental_prompt)
-    funk_rock_btn.click(set_funk_rock_prompt, inputs=bpm, outputs=instrumental_prompt)
-    detroit_techno_btn.click(set_detroit_techno_prompt, inputs=bpm, outputs=instrumental_prompt)
-    deep_house_btn.click(set_deep_house_prompt, inputs=bpm, outputs=instrumental_prompt)
+    rhcp_btn.click(set_red_hot_chili_peppers_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    nirvana_btn.click(set_nirvana_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    pearl_jam_btn.click(set_pearl_jam_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    soundgarden_btn.click(set_soundgarden_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    foo_fighters_btn.click(set_foo_fighters_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    smashing_pumpkins_btn.click(set_smashing_pumpkins_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    radiohead_btn.click(set_radiohead_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    classic_rock_btn.click(set_classic_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    alternative_rock_btn.click(set_alternative_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    post_punk_btn.click(set_post_punk_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    indie_rock_btn.click(set_indie_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    funk_rock_btn.click(set_funk_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    detroit_techno_btn.click(set_detroit_techno_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
+    deep_house_btn.click(set_deep_house_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence], outputs=instrumental_prompt)
     gen_btn.click(
         generate_music,
-        inputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, crossfade_duration, variation_crossfade_duration, num_variations, chunk_count, use_chunks, bpm],
+        inputs=[instrumental_prompt, cfg_scale, total_duration, chunk_duration, crossfade_duration, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence],
         outputs=[out_audio, status]
     )
     clr_btn.click(
         clear_inputs,
         inputs=None,
-        outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, crossfade_duration, variation_crossfade_duration, num_variations, chunk_count, use_chunks, bpm]
+        outputs=[instrumental_prompt, cfg_scale, total_duration, chunk_duration, crossfade_duration, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, vocal_presence]
     )
 
 # 9) TURN OFF OPENAPI/DOCS