Update app.py

app.py

@@ -4,7 +4,6 @@ import torchaudio
 import time
 import sys
 import numpy as np
-import gc
 import gradio as gr
 from pydub import AudioSegment
 from audiocraft.models import MusicGen
@@ -15,148 +14,908 @@ import traceback
 import logging
 from datetime import datetime
 from pathlib import Path
-import mmap
 
-# Suppress warnings
+# Suppress warnings for cleaner output
 warnings.filterwarnings("ignore")
 
-# === CUDA / Memory Configuration ===
-# Optimize allocations for RTX 2080 Ti (11.5 GB) on CUDA 12.1
+# Set PYTORCH_CUDA_ALLOC_CONF for CUDA 12.1 and 11 GB VRAM (RTX 2080 Ti)
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"
-torch.cuda.set_per_process_memory_fraction(0.95, 0)  # reserve 95% of VRAM
-torch.backends.cudnn.benchmark = True
-torch.backends.cudnn.deterministic = False
 
-# === Logging Setup ===
+# Optimize for CUDA 12.1
+torch.backends.cudnn.benchmark = False
+torch.backends.cudnn.deterministic = True
+
+# Setup logging
 log_dir = "logs"
 os.makedirs(log_dir, exist_ok=True)
-log_file = os.path.join(log_dir, f"musicgen_{datetime.now():%Y%m%d_%H%M%S}.log")
+log_file = os.path.join(log_dir, f"musicgen_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log")
 logging.basicConfig(
     level=logging.DEBUG,
     format="%(asctime)s [%(levelname)s] %(message)s",
-    handlers=[logging.FileHandler(log_file), logging.StreamHandler(sys.stdout)]
+    handlers=[
+        logging.FileHandler(log_file),
+        logging.StreamHandler(sys.stdout)
+    ]
 )
 logger = logging.getLogger(__name__)
 
-# === Device Check ===
-if not torch.cuda.is_available():
-    logger.error("CUDA is required. Exiting.")
+# Device setup
+device = "cuda" if torch.cuda.is_available() else "cpu"
+if device != "cuda":
+    logger.error("CUDA is required for GPU rendering. CPU rendering is disabled.")
     sys.exit(1)
-device = "cuda"
-logger.info(f"Using GPU: {torch.cuda.get_device_name(0)} (CUDA {torch.version.cuda})")
-
-# === Memory Cleanup ===
-def clean_memory():
-    torch.cuda.empty_cache()
-    gc.collect()
-    torch.cuda.synchronize()
-    used_mb = torch.cuda.memory_allocated() / 1024**2
-    logger.debug(f"VRAM used: {used_mb:.1f} MB")
-    return used_mb
-
-clean_memory()
+logger.info(f"Using GPU: {torch.cuda.get_device_name(0)} (CUDA 12.1, 11 GB VRAM)")
+logger.info(f"Using precision: float16 for model, float32 for processing")
 
-# === Load Model ===
+# Load MusicGen medium model into VRAM
 try:
-    model_path = os.path.expanduser("~/ghostai_musicgen/models/musicgen-medium")
-    if not os.path.isdir(model_path):
-        logger.error(f"Model path missing: {model_path}")
-        sys.exit(1)
-    musicgen = MusicGen.get_pretrained("facebook/musicgen-medium", device=device)
-    musicgen.set_generation_params(duration=30)
-    logger.info("Model loaded successfully.")
-except Exception:
-    logger.error("Model loading failed", exc_info=True)
+    logger.info("Loading MusicGen medium model into VRAM...")
+    local_model_path = "./models/musicgen-medium"
+    if not os.path.exists(local_model_path):
+        logger.warning(f"Local model path {local_model_path} does not exist. Attempting to download facebook/musicgen-medium...")
+        MusicGen.get_pretrained("facebook/musicgen-medium")
+        cache_path = os.path.expanduser("~/.cache/audiocraft/models--facebook--musicgen-medium")
+        os.makedirs(local_model_path, exist_ok=True)
+        import shutil
+        shutil.copytree(cache_path, local_model_path, dirs_exist_ok=True)
+        logger.info(f"Model weights copied to {local_model_path}")
+    musicgen_model = MusicGen.get_pretrained(local_model_path, device=device)
+    logger.info("MusicGen medium model (facebook/musicgen-medium) loaded successfully.")
+except Exception as e:
+    logger.error(f"Failed to load MusicGen model: {e}")
+    logger.error(traceback.format_exc())
     sys.exit(1)
 
-# === Utilities ===
-def check_disk_space(threshold_gb=1.0):
-    stat = os.statvfs(".")
-    free_gb = stat.f_bavail * stat.f_frsize / 1024**3
-    if free_gb < threshold_gb:
-        logger.warning(f"Low disk: {free_gb:.2f} GB free")
-    return free_gb >= threshold_gb
+# Check disk space
+def check_disk_space(path="."):
+    stat = os.statvfs(path)
+    free_space = stat.f_bavail * stat.f_frsize / (1024**3)
+    if free_space < 1.0:
+        logger.warning(f"Low disk space ({free_space:.2f} GB). Ensure at least 1 GB free.")
+    return free_space >= 1.0
 
-def rms_normalize(segment, target_db=-23.0):
+# Clear GPU memory
+def clear_gpu_memory():
+    torch.cuda.empty_cache()
+    logger.debug(f"Cleared GPU memory cache. Current VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB")
+
+# Audio processing functions (GPU-based where possible)
+def balance_stereo(audio_segment, noise_threshold=-60, sample_rate=32000):
+    logger.debug(f"Balancing stereo for segment with sample rate {sample_rate}")
+    samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+    if audio_segment.channels == 2:
+        stereo_samples = samples.reshape(-1, 2)
+        stereo_samples_torch = torch.from_numpy(stereo_samples).to(device, dtype=torch.float32)
+        db_samples = 20 * torch.log10(torch.abs(stereo_samples_torch) + 1e-10)
+        mask = db_samples > noise_threshold
+        stereo_samples_torch = stereo_samples_torch * mask
+        left_nonzero = stereo_samples_torch[:, 0][stereo_samples_torch[:, 0] != 0]
+        right_nonzero = stereo_samples_torch[:, 1][stereo_samples_torch[:, 1] != 0]
+        left_rms = torch.sqrt(torch.mean(left_nonzero**2)) if left_nonzero.numel() > 0 else torch.tensor(0.0, device=device)
+        right_rms = torch.sqrt(torch.mean(right_nonzero**2)) if right_nonzero.numel() > 0 else torch.tensor(0.0, device=device)
+        if left_rms > 0 and right_rms > 0:
+            avg_rms = (left_rms + right_rms) / 2
+            stereo_samples_torch[:, 0] = stereo_samples_torch[:, 0] * (avg_rms / left_rms)
+            stereo_samples_torch[:, 1] = stereo_samples_torch[:, 1] * (avg_rms / right_rms)
+        balanced_samples = stereo_samples_torch.cpu().numpy().flatten().astype(np.int16)
+        stereo_samples_torch = None
+        balanced_segment = AudioSegment(
+            balanced_samples.tobytes(),
+            frame_rate=sample_rate,
+            sample_width=audio_segment.sample_width,
+            channels=2
+        )
+        logger.debug("Stereo balancing completed")
+        return balanced_segment
+    logger.debug("Segment is not stereo, returning unchanged")
+    return audio_segment
+
+def calculate_rms(segment):
     samples = np.array(segment.get_array_of_samples(), dtype=np.float32)
-    rms = np.sqrt((samples**2).mean())
-    gain = target_db - (20 * np.log10(rms + 1e-9))
-    return segment.apply_gain(gain)
-
-# === Generation Function ===
-def generate_music(prompt, cfg_scale, top_k, top_p, temp, duration, bpm, drum, synth, beat, bass, guitar, volume, preset, vram):
-    clean_memory()
-    if not prompt.strip():
-        return None, "⚠️ Please enter a prompt!", vram
-    if not check_disk_space():
-        return None, "⚠️ Insufficient disk space.", vram
-
-    # Apply presets if needed
-    PRESETS = {
-        "default": {},
-        "rock": {"cfg_coef": 2.5, "temperature": 0.9},
-        "grunge": {"cfg_coef": 2.0, "temperature": 0.85},
-        "indie": {"cfg_coef": 2.2, "temperature": 0.8},
-    }
-    params = {
-        "duration": int(duration),
-        "top_k": int(top_k),
-        "top_p": top_p,
-        "temperature": temp,
-        "cfg_coef": cfg_scale
-    }
-    if preset in PRESETS:
-        params.update(PRESETS[preset])
-
-    musicgen.set_generation_params(**params)
-    logger.info(f"Generating ({duration}s)...")
-    start = time.time()
-    with torch.no_grad(), autocast():
-        wav = musicgen.generate([prompt])[0].cpu()
-    elapsed = time.time() - start
-    logger.info(f"Done in {elapsed:.1f}s")
-
-    # Save WAV → normalize → export MP3
-    wav_np = wav.numpy()
-    if wav_np.ndim == 1:
-        wav_np = np.vstack([wav_np, wav_np])
-    out_wav = f"output_{int(time.time())}.wav"
-    torchaudio.save(out_wav, torch.from_numpy(wav_np), 32000)
-    seg = AudioSegment.from_wav(out_wav)
-    seg = rms_normalize(seg, target_db=volume)
-    out_mp3 = out_wav.replace(".wav", ".mp3")
-    seg.export(out_mp3, format="mp3", bitrate="96k")
-
-    vram = f"{torch.cuda.memory_allocated()/1024**2:.1f} MB"
-    return out_mp3, f"✅ Done in {elapsed:.1f}s", vram
-
-# === Gradio Interface ===
+    samples_torch = torch.from_numpy(samples).to(device, dtype=torch.float32)
+    rms = torch.sqrt(torch.mean(samples_torch**2)).cpu().numpy()
+    samples_torch = None
+    logger.debug(f"Calculated RMS: {rms}")
+    return rms
+
+def rms_normalize(segment, target_rms_db=-23.0, peak_limit_db=-3.0, sample_rate=32000):
+    logger.debug(f"Normalizing RMS for segment with target {target_rms_db} dBFS")
+    target_rms = 10 ** (target_rms_db / 20) * 32767
+    current_rms = calculate_rms(segment)
+    if current_rms > 0:
+        gain_factor = target_rms / current_rms
+        segment = segment.apply_gain(20 * np.log10(gain_factor))
+    segment = hard_limit(segment, limit_db=peak_limit_db, sample_rate=sample_rate)
+    logger.debug("RMS normalization completed")
+    return segment
+
+def hard_limit(audio_segment, limit_db=-3.0, sample_rate=32000):
+    logger.debug(f"Applying hard limit at {limit_db} dBFS")
+    limit = 10 ** (limit_db / 20.0) * 32767
+    samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+    samples_torch = torch.from_numpy(samples).to(device, dtype=torch.float32)
+    samples_torch = torch.clamp(samples_torch, -limit, limit)
+    limited_samples = samples_torch.cpu().numpy().astype(np.int16)
+    samples_torch = None
+    limited_segment = AudioSegment(
+        limited_samples.tobytes(),
+        frame_rate=sample_rate,
+        sample_width=audio_segment.sample_width,
+        channels=audio_segment.channels
+    )
+    logger.debug("Hard limit applied")
+    return limited_segment
+
+def apply_eq(segment, sample_rate=32000):
+    logger.debug(f"Applying EQ with sample rate {sample_rate}")
+    segment = segment.high_pass_filter(20)
+    segment = segment.low_pass_filter(20000)
+    logger.debug("EQ applied")
+    return segment
+
+def apply_fade(segment, fade_in_duration=500, fade_out_duration=500):
+    logger.debug(f"Applying fade: in={fade_in_duration}ms, out={fade_out_duration}ms")
+    segment = segment.fade_in(fade_in_duration)
+    segment = segment.fade_out(fade_out_duration)
+    logger.debug("Fade applied")
+    return segment
+
+# Genre prompt functions with increased variance
+def set_red_hot_chili_peppers_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("syncopated funky steps" if bpm > 120 else "groovy rhythmic flow")
+    drum = f", {drum_beat} drums" if drum_beat != "none" else ", tight funk-rock drums with syncopated fills and crisp snares"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ", subtle wah-wah effects and ambient pads"
+    bass = f", {bass_style}" if bass_style != "none" else ", groovy slap basslines with popping accents and rhythmic flourishes"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", syncopated funky guitar riffs with staccato phrasing and wah-wah"
+    if chunk_type == "verse":
+        prompt = f"Red Hot Chili Peppers-inspired vibe with {bass}{guitar}{drum}{synth}, laid-back funky grooves, intricate bass-driven rhythms with playful syncopation, minimal guitar accents, {rhythm} at {bpm} BPM, similar to Incubus or early Faith No More."
+    elif chunk_type == "chorus":
+        prompt = f"Red Hot Chili Peppers-inspired vibe with {bass}{guitar}{drum}{synth}, explosive funky breakdowns, high-energy guitar hooks with soaring melodic riffs, punchy drum fills with dynamic crashes, {rhythm} at {bpm} BPM, similar to Incubus or early Faith No More."
+    else:  # bridge
+        prompt = f"Red Hot Chili Peppers-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric funky interlude, melodic bass solos with intricate runs, sparse wah-wah guitar textures with ambient synth layers and subdued percussion, {rhythm} at {bpm} BPM, similar to Incubus or early Faith No More."
+    logger.debug(f"Generated RHCP prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_nirvana_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", heavy grunge drums with crashing cymbals and tom rolls"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", melodic basslines with gritty distorted tone"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", raw distorted guitar riffs with feedback and slides"
+    if chunk_type == "verse":
+        prompt = f"Nirvana-inspired vibe with {bass}{guitar}{drum}{synth}, quiet grunge texture, brooding angst-filled energy with minimalistic riff patterns, subtle bass grooves, {rhythm} at {bpm} BPM, similar to Mudhoney or early Soundgarden."
+    elif chunk_type == "chorus":
+        prompt = f"Nirvana-inspired vibe with {bass}{guitar}{drum}{synth}, loud explosive grunge dynamics, chaotic distorted guitar walls with aggressive strums, pounding drum grooves with heavy cymbal crashes, {rhythm} at {bpm} BPM, similar to Mudhoney or early Soundgarden."
+    else:  # bridge
+        prompt = f"Nirvana-inspired vibe with {bass}{guitar}{drum}{synth}, moody grunge atmosphere, haunting bass-driven melody with dissonant tones, sparse feedback-heavy guitar drones with minimal percussion, {rhythm} at {bpm} BPM, similar to Mudhoney or early Soundgarden."
+    logger.debug(f"Generated Nirvana prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_pearl_jam_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", driving grunge drums with tom-heavy fills and deep kicks"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", deep resonant basslines with melodic runs"
+    guitar = f", {guitar_style} guitar leads" if guitar_style != "none" else ", soulful guitar leads with reverb and bends"
+    if chunk_type == "verse":
+        prompt = f"Pearl Jam-inspired vibe with {bass}{guitar}{drum}{synth}, emotional grunge storytelling, steady soulful grooves with warm bass tones, lyrical guitar phrases with subtle dynamics, {rhythm} at {bpm} BPM, similar to Alice in Chains."
+    elif chunk_type == "chorus":
+        prompt = f"Pearl Jam-inspired vibe with {bass}{guitar}{drum}{synth}, soaring grunge choruses, powerful guitar solos with emotive bends and slides, intense rhythmic drive with dynamic tom fills, {rhythm} at {bpm} BPM, similar to Alice in Chains."
+    else:  # bridge
+        prompt = f"Pearl Jam-inspired vibe with {bass}{guitar}{drum}{synth}, introspective grunge atmosphere, melodic bass and reverb-heavy guitar interplay with atmospheric textures and soft percussion, {rhythm} at {bpm} BPM, similar to Alice in Chains."
+    logger.debug(f"Generated Pearl Jam prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_soundgarden_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", heavy sludgy drums with syncopated patterns and deep toms"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", heavy distorted basslines with growling tone"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", heavy sludgy guitar riffs with drop tunings and slides"
+    if chunk_type == "verse":
+        prompt = f"Soundgarden-inspired vibe with {bass}{guitar}{drum}{synth}, dark grunge texture, brooding psychedelic undertones with sludgy bass-heavy rhythms, minimal guitar accents, {rhythm} at {bpm} BPM, similar to Temple of the Dog."
+    elif chunk_type == "chorus":
+        prompt = f"Soundgarden-inspired vibe with {bass}{guitar}{drum}{synth}, powerful grunge riffs, soaring vocal-like guitar melodies with heavy distortion, dynamic drum grooves with intense fills, {rhythm} at {bpm} BPM, similar to Temple of the Dog."
+    else:  # bridge
+        prompt = f"Soundgarden-inspired vibe with {bass}{guitar}{drum}{synth}, psychedelic grunge atmosphere, hypnotic bass-driven grooves with droning guitar textures and sparse percussion, {rhythm} at {bpm} BPM, similar to Temple of the Dog."
+    logger.debug(f"Generated Soundgarden prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_foo_fighters_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    styles = ["anthemic", "gritty", "melodic", "fast-paced", "driving"]
+    moods = ["energetic", "introspective", "rebellious", "uplifting"]
+    style = random.choice(styles)
+    mood = random.choice(moods)
+    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 ", driving rock drums with punchy fills and tight snares"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", driving basslines with melodic hooks and syncopation"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else f", {style} guitar riffs with crunchy distortion and palm muting"
+    if chunk_type == "verse":
+        prompt = f"Foo Fighters-inspired vibe with {bass}{guitar}{drum}{synth}, {mood} alt-rock energy, catchy verse riffs with rhythmic bass grooves, steady driving pulse with subtle dynamics, {rhythm} at {bpm} BPM, similar to Queens of the Stone Age."
+    elif chunk_type == "chorus":
+        prompt = f"Foo Fighters-inspired vibe with {bass}{guitar}{drum}{synth}, {mood} alt-rock power, anthemic choruses with explosive guitar hooks and soaring melodies, punchy drum fills with crashing cymbals, {rhythm} at {bpm} BPM, similar to Queens of the Stone Age."
+    else:  # bridge
+        prompt = f"Foo Fighters-inspired vibe with {bass}{guitar}{drum}{synth}, {mood} alt-rock atmosphere, melodic guitar and bass interplay with atmospheric textures and subdued percussion, {rhythm} at {bpm} BPM, similar to Queens of the Stone Age."
+    logger.debug(f"Generated Foo Fighters prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_smashing_pumpkins_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", layered alt-rock drums with syncopated patterns and reverb"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", melodic basslines with warm resonant tone"
+    guitar = f", {guitar_style} guitar textures" if guitar_style != "none" else ", dreamy layered guitar textures with chorus effects"
+    if chunk_type == "verse":
+        prompt = f"Smashing Pumpkins-inspired vibe with {bass}{guitar}{drum}{synth}, melancholic alt-rock texture, intricate layered dynamics with delicate guitar arpeggios and steady bass grooves, {rhythm} at {bpm} BPM, similar to My Bloody Valentine."
+    elif chunk_type == "chorus":
+        prompt = f"Smashing Pumpkins-inspired vibe with {bass}{guitar}{drum}{synth}, aggressive alt-rock energy, soaring distorted guitar walls with pounding drum grooves and intense basslines, {rhythm} at {bpm} BPM, similar to My Bloody Valentine."
+    else:  # bridge
+        prompt = f"Smashing Pumpkins-inspired vibe with {bass}{guitar}{drum}{synth}, dreamy alt-rock atmosphere, ethereal guitar and bass interplay with ambient textures and soft percussion, {rhythm} at {bpm} BPM, similar to My Bloody Valentine."
+    logger.debug(f"Generated Smashing Pumpkins prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_radiohead_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", intricate experimental drums with glitchy offbeat patterns"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ", atmospheric synths with evolving textures and drones"
+    bass = f", {bass_style}" if bass_style != "none" else ", subtle pulsing basslines with ambient resonance"
+    guitar = f", {guitar_style} guitar layers" if guitar_style != "none" else ", intricate ambient guitar layers with delay effects"
+    if chunk_type == "verse":
+        prompt = f"Radiohead-inspired vibe with {bass}{guitar}{drum}{synth}, introspective experimental rock, delicate layered textures with glitchy rhythms and minimal bass pulses, {rhythm} at {bpm} BPM, similar to Sigur Rós."
+    elif chunk_type == "chorus":
+        prompt = f"Radiohead-inspired vibe with {bass}{guitar}{drum}{synth}, climactic experimental rock, intense layered dynamics with soaring synth melodies and chaotic guitar lines, {rhythm} at {bpm} BPM, similar to Sigur Rós."
+    else:  # bridge
+        prompt = f"Radiohead-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric experimental rock, ambient synth and guitar drones with minimalist bass pulses and sparse percussion, {rhythm} at {bpm} BPM, similar to Sigur Rós."
+    logger.debug(f"Generated Radiohead prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_classic_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", classic rock drums with rolling fills and deep kicks"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", groovy walking bass with melodic runs"
+    guitar = f", {guitar_style} electric guitars" if guitar_style != "none" else ", bluesy electric guitars with vibrato and bends"
+    if chunk_type == "verse":
+        prompt = f"Led Zeppelin-inspired vibe with {bass}{guitar}{drum}{synth}, raw classic rock energy, bluesy rhythmic grooves with steady bass walks and minimal guitar riffs, {rhythm} at {bpm} BPM, similar to The Who."
+    elif chunk_type == "chorus":
+        prompt = f"Led Zeppelin-inspired vibe with {bass}{guitar}{drum}{synth}, explosive classic rock riffs, fiery guitar solos with soaring melodies and driving drum grooves, {rhythm} at {bpm} BPM, similar to The Who."
+    else:  # bridge
+        prompt = f"Led Zeppelin-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric classic rock texture, melodic bass and slide guitar interplay with ambient reverb and sparse percussion, {rhythm} at {bpm} BPM, similar to The Who."
+    logger.debug(f"Generated Classic Rock prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_alternative_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", quirky alt-rock drums with offbeat fills and tight snares"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", melodic basslines with syncopated grooves"
+    guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", distorted guitar riffs with angular phrasing and reverb"
+    if chunk_type == "verse":
+        prompt = f"Pixies-inspired vibe with {bass}{guitar}{drum}{synth}, quirky alt-rock energy, playful dynamic shifts with rhythmic bass grooves and minimal guitar accents, {rhythm} at {bpm} BPM, similar to Sonic Youth."
+    elif chunk_type == "chorus":
+        prompt = f"Pixies-inspired vibe with {bass}{guitar}{drum}{synth}, explosive alt-rock intensity, jagged guitar hooks with soaring melodies and driving drum patterns, {rhythm} at {bpm} BPM, similar to Sonic Youth."
+    else:  # bridge
+        prompt = f"Pixies-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric alt-rock texture, dissonant guitar and bass interplay with ambient reverb and sparse percussion, {rhythm} at {bpm} BPM, similar to Sonic Youth."
+    logger.debug(f"Generated Alternative Rock prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_post_punk_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", hypnotic post-punk drums with reverb and sharp hi-hats"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", driving basslines with dark resonant tone"
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ", jangly guitars with chorus effects and sharp picking"
+    if chunk_type == "verse":
+        prompt = f"Joy Division-inspired vibe with {bass}{guitar}{drum}{synth}, moody post-punk atmosphere, hypnotic minimalist grooves with steady bass pulse and subtle guitar accents, {rhythm} at {bpm} BPM, similar to The Cure."
+    elif chunk_type == "chorus":
+        prompt = f"Joy Division-inspired vibe with {bass}{guitar}{drum}{synth}, intense post-punk energy, driving bass and jangly guitar hooks with soaring dynamics and reverb-heavy drums, {rhythm} at {bpm} BPM, similar to The Cure."
+    else:  # bridge
+        prompt = f"Joy Division-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric post-punk texture, reverb-heavy bass and guitar drones with sparse percussion and ambient tones, {rhythm} at {bpm} BPM, similar to The Cure."
+    logger.debug(f"Generated Post-Punk prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_indie_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", catchy indie drums with tight snares and offbeat fills"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", melodic basslines with upbeat syncopated pulse"
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ", jangly guitars with bright chords and reverb"
+    if chunk_type == "verse":
+        prompt = f"Arctic Monkeys-inspired vibe with {bass}{guitar}{drum}{synth}, catchy indie rock grooves, sharp rhythmic riffs with steady bass grooves and minimal guitar accents, {rhythm} at {bpm} BPM, similar to The Strokes."
+    elif chunk_type == "chorus":
+        prompt = f"Arctic Monkeys-inspired vibe with {bass}{guitar}{drum}{synth}, high-energy indie rock hooks, punchy guitar and bass interplay with soaring melodic riffs, driving drum patterns, {rhythm} at {bpm} BPM, similar to The Strokes."
+    else:  # bridge
+        prompt = f"Arctic Monkeys-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric indie rock texture, melodic jangly guitar leads with ambient reverb and sparse percussion, {rhythm} at {bpm} BPM, similar to The Strokes."
+    logger.debug(f"Generated Indie Rock prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_funk_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", tight funk-rock drums with heavy kicks and syncopated fills"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ""
+    bass = f", {bass_style}" if bass_style != "none" else ", slap bass with aggressive pops and rhythmic flourishes"
+    guitar = f", {guitar_style} guitar chords" if guitar_style != "none" else ", funky guitar chords with wah-wah and staccato strums"
+    if chunk_type == "verse":
+        prompt = f"Rage Against the Machine-inspired vibe with {bass}{guitar}{drum}{synth}, aggressive funk-rock grooves, heavy syncopated bass rhythms with gritty guitar accents, {rhythm} at {bpm} BPM, similar to Audioslave."
+    elif chunk_type == "chorus":
+        prompt = f"Rage Against the Machine-inspired vibe with {bass}{guitar}{drum}{synth}, explosive funk-rock energy, powerful riff-driven hooks with intense drum grooves and dynamic basslines, {rhythm} at {bpm} BPM, similar to Audioslave."
+    else:  # bridge
+        prompt = f"Rage Against the Machine-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric funk-rock interlude, bass-heavy grooves with sparse wah-wah guitar effects and subtle percussion, {rhythm} at {bpm} BPM, similar to Audioslave."
+    logger.debug(f"Generated Funk Rock prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_detroit_techno_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 and steady four-on-the-floor kick drum with subtle variations"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ", deep pulsing synths with repetitive arpeggiated patterns"
+    bass = f", {bass_style}" if bass_style != "none" else ", driving basslines with groovy resonant pulse"
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ""
+    if chunk_type == "verse":
+        prompt = f"Juan Atkins-inspired vibe with {bass}{guitar}{drum}{synth}, hypnotic Detroit techno grooves, minimalistic pulsing rhythms with steady bass pulse and subtle synth textures, {rhythm} at {bpm} BPM, similar to Derrick May."
+    elif chunk_type == "chorus":
+        prompt = f"Juan Atkins-inspired vibe with {bass}{guitar}{drum}{synth}, intense Detroit techno energy, layered synth arpeggios with dynamic basslines and vibrant synth leads, {rhythm} at {bpm} BPM, similar to Derrick May."
+    else:  # bridge
+        prompt = f"Juan Atkins-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric Detroit techno texture, deep resonant bass and ambient synth drones with minimal percussion, {rhythm} at {bpm} BPM, similar to Derrick May."
+    logger.debug(f"Generated Detroit Techno prompt for {chunk_type}: {prompt}")
+    return prompt
+
+def set_deep_house_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type="verse"):
+    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 ", steady four-on-the-floor kick drum with soft hi-hats and subtle shakers"
+    synth = f", {synthesizer} accents" if synthesizer != "none" else ", warm analog synth chords with hypnotic progression and ambient pads"
+    bass = f", {bass_style}" if bass_style != "none" else ", deep basslines with groovy pulsing rhythm"
+    guitar = f", {guitar_style} guitars" if guitar_style != "none" else ""
+    if chunk_type == "verse":
+        prompt = f"Larry Heard-inspired vibe with {bass}{guitar}{drum}{synth}, laid-back deep house grooves, soulful chord progressions with steady bass pulse and minimal synth accents, {rhythm} at {bpm} BPM, similar to Frankie Knuckles."
+    elif chunk_type == "chorus":
+        prompt = f"Larry Heard-inspired vibe with {bass}{guitar}{drum}{synth}, uplifting deep house energy, rich layered synths with dynamic basslines and vibrant chord progressions, {rhythm} at {bpm} BPM, similar to Frankie Knuckles."
+    else:  # bridge
+        prompt = f"Larry Heard-inspired vibe with {bass}{guitar}{drum}{synth}, atmospheric deep house texture, warm resonant bass and ambient synth pads with minimal percussion and subtle hi-hat patterns, {rhythm} at {bpm} BPM, similar to Frankie Knuckles."
+    logger.debug(f"Generated Deep House prompt for {chunk_type}: {prompt}")
+    return prompt
+
+# Preset configurations for genres
+PRESETS = {
+    "default": {"cfg_scale": 2.0, "top_k": 150, "top_p": 0.9, "temperature": 0.8},
+    "rock": {"cfg_scale": 2.5, "top_k": 140, "top_p": 0.9, "temperature": 0.9},
+    "techno": {"cfg_scale": 1.8, "top_k": 160, "top_p": 0.85, "temperature": 0.7},
+    "grunge": {"cfg_scale": 2.0, "top_k": 150, "top_p": 0.9, "temperature": 0.85},
+    "indie": {"cfg_scale": 2.2, "top_k": 145, "top_p": 0.9, "temperature": 0.8}
+}
+
+# Function to get the latest log file
+def get_latest_log():
+    log_files = sorted(Path(log_dir).glob("musicgen_log_*.log"), key=os.path.getmtime, reverse=True)
+    if not log_files:
+        logger.warning("No log files found")
+        return "No log files found."
+    try:
+        with open(log_files[0], "r") as f:
+            content = f.read()
+        logger.info(f"Retrieved latest log file: {log_files[0]}")
+        return content
+    except Exception as e:
+        logger.error(f"Failed to read log file {log_files[0]}: {e}")
+        return f"Error reading log file: {e}"
+
+# Generate a single track segment
+def generate_segment(prompt, cfg_scale, top_k, top_p, temperature, duration, seed, target_volume, preset):
+    global musicgen_model
+    try:
+        logger.info(f"Generating segment ({duration}s, seed={seed})")
+        if preset != "default":
+            preset_params = PRESETS.get(preset, PRESETS["default"])
+            cfg_scale = preset_params["cfg_scale"]
+            top_k = preset_params["top_k"]
+            top_p = preset_params["top_p"]
+            temperature = preset_params["temperature"]
+            logger.info(f"Applied preset {preset}: cfg_scale={cfg_scale}, top_k={top_k}, top_p={top_p}, temperature={temperature}")
+
+        # Calculate expected steps (~50 steps/second at 32000 Hz)
+        expected_steps = int(duration * 50)
+        logger.debug(f"Setting duration={duration}s, expected_steps={expected_steps}")
+
+        musicgen_model.set_generation_params(
+            duration=duration,
+            use_sampling=True,
+            top_k=top_k,
+            top_p=top_p,
+            temperature=temperature,
+            cfg_coef=cfg_scale
+        )
+
+        with torch.no_grad():
+            with autocast(dtype=torch.float16):
+                torch.manual_seed(seed)
+                np.random.seed(seed)
+                torch.cuda.manual_seed_all(seed)
+                logger.debug("Generating track")
+                audio_segment = musicgen_model.generate([prompt], progress=True)[0].to(device)
+                logger.debug(f"Generated audio segment shape: {audio_segment.shape}")
+
+        # Verify duration
+        sample_rate = 32000
+        expected_samples = duration * sample_rate
+        actual_samples = audio_segment.shape[-1]
+        logger.debug(f"Expected samples: {expected_samples}, Actual samples: {actual_samples}")
+        if abs(actual_samples - expected_samples) > sample_rate:  # Allow 1s tolerance
+            logger.warning(f"Generated audio duration mismatch: expected {duration}s, got {actual_samples/sample_rate:.2f}s")
+
+        audio_segment = audio_segment.to(dtype=torch.float32)
+        if audio_segment.dim() == 1:
+            logger.debug("Converting mono to stereo")
+            audio_segment = torch.stack([audio_segment, audio_segment], dim=0)
+        elif audio_segment.dim() == 2 and audio_segment.shape[0] != 2:
+            logger.debug("Adjusting to stereo")
+            audio_segment = torch.cat([audio_segment, audio_segment], dim=0)
+
+        if audio_segment.shape[0] != 2:
+            logger.error(f"Expected stereo audio with shape (2, samples), got shape {audio_segment.shape}")
+            raise ValueError(f"Expected stereo audio with shape (2, samples), got shape {audio_segment.shape}")
+
+        temp_wav_path = f"temp_audio_{int(time.time()*1000)}.wav"
+        logger.debug(f"Saving audio segment to {temp_wav_path}")
+        torchaudio.save(temp_wav_path, audio_segment.cpu(), sample_rate, bits_per_sample=16)
+        final_segment = AudioSegment.from_wav(temp_wav_path)
+        os.remove(temp_wav_path)
+        logger.debug(f"Deleted temporary file {temp_wav_path}")
+        final_segment = final_segment - 15
+        if final_segment.frame_rate != sample_rate:
+            logger.debug(f"Setting segment sample rate to {sample_rate}")
+            final_segment = final_segment.set_frame_rate(sample_rate)
+        final_segment = balance_stereo(final_segment, noise_threshold=-60, sample_rate=sample_rate)
+        final_segment = rms_normalize(final_segment, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=sample_rate)
+        final_segment = apply_eq(final_segment, sample_rate=sample_rate)
+        clear_gpu_memory()
+        return final_segment
+    except Exception as e:
+        logger.error(f"Segment generation failed: {e}")
+        logger.error(traceback.format_exc())
+        clear_gpu_memory()
+        raise e
+
+# Generate a full 180-second song with chunking
+def generate_full_song(prompt_func, cfg_scale, top_k, top_p, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume, preset, seed, vram_status):
+    try:
+        logger.info("Starting full song generation (180s, 3 chunks)...")
+        start_time = time.time()
+        chunks = []
+        chunk_types = ["verse", "chorus", "bridge"]
+        sample_rate = 32000
+        chunk_params = [
+            {"temperature": 1.0, "top_p": 0.975, "seed_offset": 0},    # Verse: moderate randomness
+            {"temperature": 1.05, "top_p": 1.0, "seed_offset": 50},    # Chorus: balanced
+            {"temperature": 1.1, "top_p": 1.025, "seed_offset": 100}   # Bridge: most varied
+        ]
+
+        if not check_disk_space():
+            logger.error("Insufficient disk space")
+            return None, "⚠️ Insufficient disk space. Free up at least 1 GB.", vram_status
+
+        vram_status = f"Initial VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+
+        for i, (chunk_type, params) in enumerate(zip(chunk_types, chunk_params)):
+            logger.info(f"Generating chunk {i+1}/3 ({chunk_type}, 60s, seed={seed + params['seed_offset']}, VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB)")
+            chunk_start = time.time()
+            for attempt in range(3):  # Retry up to 3 times
+                try:
+                    prompt = prompt_func(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, chunk_type)
+                    chunk = generate_segment(
+                        prompt, cfg_scale, top_k, params["top_p"], params["temperature"], 60,
+                        seed + params["seed_offset"], target_volume, preset
+                    )
+                    # Adjust fades for smooth transitions
+                    if i == 0:
+                        chunk = chunk.fade_in(500).fade_out(2000)  # Verse: fade in, longer fade out
+                    elif i == 1:
+                        chunk = chunk.fade_in(2000).fade_out(2000)  # Chorus: crossfade both
+                    else:
+                        chunk = chunk.fade_in(2000).fade_out(500)  # Bridge: longer fade in, fade out
+                    chunks.append(chunk)
+                    logger.info(f"Chunk {i+1} generated in {time.time() - chunk_start:.2f} seconds")
+                    break
+                except Exception as e:
+                    logger.warning(f"Chunk {i+1} attempt {attempt+1} failed: {e}")
+                    clear_gpu_memory()
+                    if attempt == 2:
+                        raise e
+            clear_gpu_memory()
+
+        # Combine chunks with crossfades
+        logger.debug("Combining chunks with crossfades")
+        combined = chunks[0]
+        for i in range(1, len(chunks)):
+            combined = combined.append(chunks[i], crossfade=2000)  # 2-second crossfade
+
+        mp3_path = f"output_full_song_{int(time.time())}.mp3"
+        logger.info("⚠️ WARNING: Audio is set to safe levels (~ -23 dBFS RMS, -3 dBFS peak). Start playback at LOW volume (10-20%) and adjust gradually.")
+        logger.info("VERIFY: Open the file in Audacity to check for static. RMS should be ~ -23 dBFS, peaks ≤ -3 dBFS. Report any static or issues.")
+        try:
+            logger.debug(f"Exporting full song to {mp3_path}")
+            combined.export(
+                mp3_path,
+                format="mp3",
+                bitrate="96k",
+                tags={"title": "GhostAI Full Song", "artist": "GhostAI"}
+            )
+            logger.info(f"Full song saved to {mp3_path}")
+        except Exception as e:
+            logger.error(f"Error exporting MP3: {e}")
+            fallback_path = f"fallback_full_song_{int(time.time())}.mp3"
+            try:
+                combined.export(fallback_path, format="mp3", bitrate="96k")
+                logger.info(f"Full song saved to fallback: {fallback_path}")
+                mp3_path = fallback_path
+            except Exception as fallback_e:
+                logger.error(f"Failed to save fallback MP3: {fallback_e}")
+                raise e
+
+        vram_status = f"Final VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+        logger.info(f"Full song generation completed in {time.time() - start_time:.2f} seconds")
+        return mp3_path, "✅ Done! Generated static-free full song (180s) with adjusted volume levels.", vram_status
+    except Exception as e:
+        logger.error(f"Full song generation failed: {e}")
+        logger.error(traceback.format_exc())
+        return None, f"❌ Full song generation failed: {e}", vram_status
+
+# Generate music (single track or full song)
+def generate_music(instrumental_prompt, cfg_scale, top_k, top_p, temperature, duration, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume, preset, vram_status):
+    global musicgen_model
+    if not instrumental_prompt.strip():
+        logger.warning("Empty instrumental prompt provided")
+        return None, "⚠️ Please enter a valid instrumental prompt!", vram_status
+
+    try:
+        logger.info("Starting music generation...")
+        start_time = time.time()
+        sample_rate = 32000
+
+        if not check_disk_space():
+            logger.error("Insufficient disk space")
+            return None, "⚠️ Insufficient disk space. Free up at least 1 GB.", vram_status
+
+        seed = random.randint(1, 100)
+        vram_status = f"Initial VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+
+        if duration == "Full Song (180 seconds)":
+            # Map prompt to corresponding function for chunking
+            prompt_func_map = {
+                "rhcp": set_red_hot_chili_peppers_prompt,
+                "nirvana": set_nirvana_grunge_prompt,
+                "pearl_jam": set_pearl_jam_grunge_prompt,
+                "soundgarden": set_soundgarden_grunge_prompt,
+                "foo_fighters": set_foo_fighters_prompt,
+                "smashing_pumpkins": set_smashing_pumpkins_prompt,
+                "radiohead": set_radiohead_prompt,
+                "classic_rock": set_classic_rock_prompt,
+                "alternative_rock": set_alternative_rock_prompt,
+                "post_punk": set_post_punk_prompt,
+                "indie_rock": set_indie_rock_prompt,
+                "funk_rock": set_funk_rock_prompt,
+                "detroit_techno": set_detroit_techno_prompt,
+                "deep_house": set_deep_house_prompt
+            }
+            prompt_key = None
+            for key, func in prompt_func_map.items():
+                if func(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, "verse") == instrumental_prompt:
+                    prompt_key = key
+                    break
+            if not prompt_key:
+                logger.error("Prompt does not match any genre function")
+                return None, "⚠️ Prompt does not match any supported genre!", vram_status
+            return generate_full_song(
+                prompt_func_map[prompt_key], cfg_scale, top_k, top_p, bpm, drum_beat,
+                synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume, preset, seed, vram_status
+            )
+
+        # Single track generation
+        logger.info(f"Generating single track ({duration}, seed={seed})")
+        duration_secs = 30 if duration == "30 seconds" else 60
+        final_segment = generate_segment(
+            instrumental_prompt, cfg_scale, top_k, top_p, temperature, duration_secs, seed, target_volume, preset
+        )
+        final_segment = apply_fade(final_segment)
+
+        mp3_path = f"output_adjusted_volume_{int(time.time())}.mp3"
+        logger.info("⚠️ WARNING: Audio is set to safe levels (~ -23 dBFS RMS, -3 dBFS peak). Start playback at LOW volume (10-20%) and adjust gradually.")
+        logger.info("VERIFY: Open the file in Audacity to check for static. RMS should be ~ -23 dBFS, peaks ≤ -3 dBFS. Report any static or issues.")
+        try:
+            logger.debug(f"Exporting single track to {mp3_path}")
+            final_segment.export(
+                mp3_path,
+                format="mp3",
+                bitrate="96k",
+                tags={"title": "GhostAI Instrumental", "artist": "GhostAI"}
+            )
+            logger.info(f"Single track saved to {mp3_path}")
+        except Exception as e:
+            logger.error(f"Error exporting MP3: {e}")
+            fallback_path = f"fallback_output_{int(time.time())}.mp3"
+            try:
+                final_segment.export(fallback_path, format="mp3", bitrate="96k")
+                logger.info(f"Single track saved to fallback: {fallback_path}")
+                mp3_path = fallback_path
+            except Exception as fallback_e:
+                logger.error(f"Failed to save fallback MP3: {fallback_e}")
+                raise e
+
+        vram_status = f"Final VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+        logger.info(f"Single track generation completed in {time.time() - start_time:.2f} seconds")
+        return mp3_path, "✅ Done! Generated static-free track with adjusted volume levels.", vram_status
+    except Exception as e:
+        logger.error(f"Generation failed: {e}")
+        logger.error(traceback.format_exc())
+        return None, f"❌ Generation failed: {e}", vram_status
+
+# Clear inputs function
+def clear_inputs():
+    logger.info("Clearing input fields")
+    return "", 2.0, 150, 0.9, 0.8, "30 seconds", 120, "none", "none", "none", "none", "none", -23.0, "default", ""
+
+# Custom CSS
 css = """
-body { background: #0A0A0A; color: #E0E0E0; font-family: 'Orbitron',sans-serif; }
-...
+body { 
+    background: linear-gradient(135deg, #0A0A0A 0%, #1C2526 100%); 
+    color: #E0E0E0; 
+    font-family: 'Orbitron', sans-serif; 
+}
+.header-container { 
+    text-align: center; 
+    padding: 10px 20px; 
+    background: rgba(0, 0, 0, 0.9); 
+    border-bottom: 1px solid #00FF9F; 
+}
+#ghost-logo { 
+    font-size: 40px; 
+    animation: glitch-ghost 1.5s infinite; 
+}
+h1 { 
+    color: #A100FF; 
+    font-size: 24px; 
+    animation: glitch-text 2s infinite; 
+}
+p { 
+    color: #E0E0E0; 
+    font-size: 12px; 
+}
+.input-container, .settings-container, .output-container, .logs-container { 
+    max-width: 1200px; 
+    margin: 20px auto; 
+    padding: 20px; 
+    background: rgba(28, 37, 38, 0.8); 
+    border-radius: 10px; 
+}
+.textbox { 
+    background: #1A1A1A; 
+    border: 1px solid #A100FF; 
+    color: #E0E0E0; 
+}
+.genre-buttons { 
+    display: flex; 
+    justify-content: center; 
+    flex-wrap: wrap; 
+    gap: 15px; 
+}
+.genre-btn, button { 
+    background: linear-gradient(45deg, #A100FF, #00FF9F); 
+    border: none; 
+    color: #0A0A0A; 
+    padding: 10px 20px; 
+    border-radius: 5px; 
+}
+.gradio-container { 
+    padding: 20px; 
+}
+.group-container { 
+    margin-bottom: 20px; 
+    padding: 15px; 
+    border: 1px solid #00FF9F; 
+    border-radius: 8px; 
+}
+@keyframes glitch-ghost { 
+    0% { transform: translate(0, 0); opacity: 1; }
+    20% { transform: translate(-5px, 2px); opacity: 0.8; }
+    100% { transform: translate(0, 0); opacity: 1; }
+}
+@keyframes glitch-text { 
+    0% { transform: translate(0, 0); }
+    20% { transform: translate(-2px, 1px); }
+    100% { transform: translate(0, 0); }
+}
+@font-face { 
+    font-family: 'Orbitron'; 
+    src: url('https://fonts.gstatic.com/s/orbitron/v29/yMJRMIlzdpvBhQQL_Qq7dy0.woff2') format('woff2'); 
+}
 """
 
+# Build Gradio interface
+logger.info("Building Gradio interface...")
 with gr.Blocks(css=css) as demo:
-    gr.Markdown("## GhostAI Music Generator")
-    inp = gr.Textbox(label="Prompt", lines=2)
-    cfg = gr.Slider(1,10,2, label="CFG Scale")
-    k = gr.Slider(10,500,150, label="Top-K")
-    p = gr.Slider(0.0,1.0,0.9, step=0.05, label="Top-P")
-    t = gr.Slider(0.1,2.0,0.8, step=0.1, label="Temperature")
-    dur = gr.Slider(30,120,30, step=30, label="Duration (s)")
-    bpm = gr.Slider(60,180,120, label="BPM")
-    drum = gr.Dropdown(["none","rock","funk"], value="none", label="Drum")
-    synth = gr.Dropdown(["none","analog","digital"], value="none", label="Synth")
-    beat = gr.Dropdown(["none","syncopated","steady"], value="none", label="Beat")
-    bass = gr.Dropdown(["none","slap","deep"], value="none", label="Bass")
-    guitar = gr.Dropdown(["none","clean","distort"], value="none", label="Guitar")
-    vol = gr.Slider(-30,-20,-23, step=1, label="Volume (dBFS)")
-    preset = gr.Dropdown(["default","rock","grunge","indie"], value="default", label="Preset")
-    vram_tb = gr.Textbox(label="VRAM", interactive=False)
-    out_audio = gr.Audio()
-    btn = gr.Button("Generate")
-    btn.click(generate_music,
-              inputs=[inp,cfg,k,p,t,dur,bpm,drum,synth,beat,bass,guitar,vol,preset,vram_tb],
-              outputs=[out_audio, gr.Textbox(label="Status"), vram_tb])
-
-demo.launch(server_name="0.0.0.0", server_port=9999, share=False)
+    gr.Markdown("""
+        <div class="header-container">
+            <div id="ghost-logo">👻</div>
+            <h1>GhostAI Music Generator 🎹</h1>
+            <p>Summon the Sound of the Unknown</p>
+        </div>
+    """)
+    
+    with gr.Column(elem_classes="input-container"):
+        gr.Markdown("### 🎸 Prompt Settings")
+        instrumental_prompt = gr.Textbox(
+            label="Instrumental Prompt ✍️",
+            placeholder="Click a genre button or type your own instrumental prompt",
+            lines=4,
+            elem_classes="textbox"
+        )
+        with gr.Row(elem_classes="genre-buttons"):
+            rhcp_btn = gr.Button("Red Hot Chili Peppers 🌶️", elem_classes="genre-btn")
+            nirvana_btn = gr.Button("Nirvana Grunge 🎸", elem_classes="genre-btn")
+            pearl_jam_btn = gr.Button("Pearl Jam Grunge 🦪", elem_classes="genre-btn")
+            soundgarden_btn = gr.Button("Soundgarden Grunge 🌑", elem_classes="genre-btn")
+            foo_fighters_btn = gr.Button("Foo Fighters 🤘", elem_classes="genre-btn")
+            smashing_pumpkins_btn = gr.Button("Smashing Pumpkins 🎃", elem_classes="genre-btn")
+            radiohead_btn = gr.Button("Radiohead 🧠", elem_classes="genre-btn")
+            classic_rock_btn = gr.Button("Classic Rock 🎸", elem_classes="genre-btn")
+            alternative_rock_btn = gr.Button("Alternative Rock 🎵", elem_classes="genre-btn")
+            post_punk_btn = gr.Button("Post-Punk 🖤", elem_classes="genre-btn")
+            indie_rock_btn = gr.Button("Indie Rock 🎤", elem_classes="genre-btn")
+            funk_rock_btn = gr.Button("Funk Rock 🕺", elem_classes="genre-btn")
+            detroit_techno_btn = gr.Button("Detroit Techno 🎛️", elem_classes="genre-btn")
+            deep_house_btn = gr.Button("Deep House 🏠", elem_classes="genre-btn")
+    
+    with gr.Column(elem_classes="settings-container"):
+        gr.Markdown("### ⚙️ API Settings")
+        with gr.Group(elem_classes="group-container"):
+            cfg_scale = gr.Slider(
+                label="CFG Scale 🎯",
+                minimum=1.0,
+                maximum=10.0,
+                value=2.0,
+                step=0.1,
+                info="Controls how closely the music follows the prompt."
+            )
+            top_k = gr.Slider(
+                label="Top-K Sampling 🔢",
+                minimum=10,
+                maximum=500,
+                value=150,
+                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=0.8,
+                step=0.1,
+                info="Controls randomness; lower values reduce noise."
+            )
+            duration = gr.Radio(
+                label="Song Length ⏳",
+                choices=["30 seconds", "60 seconds", "Full Song (180 seconds)"],
+                value="30 seconds",
+                info="Select the duration of the track. Full Song generates a 180s track with three 60s chunks (verse, chorus, bridge)."
+            )
+            bpm = gr.Slider(
+                label="Tempo 🎵 (BPM)",
+                minimum=60,
+                maximum=180,
+                value=120,
+                step=1,
+                info="Beats per minute to set 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 for 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."
+            )
+            target_volume = gr.Slider(
+                label="Target Volume 🎚️ (dBFS RMS)",
+                minimum=-30.0,
+                maximum=-20.0,
+                value=-23.0,
+                step=1.0,
+                info="Adjust output loudness (-23 dBFS is standard, -20 dBFS is louder, -30 dBFS is quieter)."
+            )
+            preset = gr.Dropdown(
+                label="Preset Configuration 🎛️",
+                choices=["default", "rock", "techno", "grunge", "indie"],
+                value="default",
+                info="Select a preset optimized for specific genres."
+            )
+
+        with gr.Row(elem_classes="action-buttons"):
+            gen_btn = gr.Button("Generate Music 🚀")
+            clr_btn = gr.Button("Clear Inputs 🧹")
+    
+    with gr.Column(elem_classes="output-container"):
+        gr.Markdown("### 🎧 Output")
+        out_audio = gr.Audio(label="Generated Instrumental Track 🎵", type="filepath")
+        status = gr.Textbox(label="Status 📢", interactive=False)
+        vram_status = gr.Textbox(label="VRAM Usage 📊", interactive=False, value="")
+
+    with gr.Column(elem_classes="logs-container"):
+        gr.Markdown("### 📜 Logs")
+        log_output = gr.Textbox(label="Last Log File Contents", lines=20, interactive=False)
+        log_btn = gr.Button("View Last Log 📋")
+
+    rhcp_btn.click(set_red_hot_chili_peppers_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    nirvana_btn.click(set_nirvana_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    pearl_jam_btn.click(set_pearl_jam_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    soundgarden_btn.click(set_soundgarden_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    foo_fighters_btn.click(set_foo_fighters_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    smashing_pumpkins_btn.click(set_smashing_pumpkins_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    radiohead_btn.click(set_radiohead_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    classic_rock_btn.click(set_classic_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    alternative_rock_btn.click(set_alternative_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    post_punk_btn.click(set_post_punk_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    indie_rock_btn.click(set_indie_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    funk_rock_btn.click(set_funk_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    detroit_techno_btn.click(set_detroit_techno_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    deep_house_btn.click(set_deep_house_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, gr.State("verse")], outputs=instrumental_prompt)
+    gen_btn.click(
+        generate_music,
+        inputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, duration, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume, preset, vram_status],
+        outputs=[out_audio, status, vram_status]
+    )
+    clr_btn.click(
+        clear_inputs,
+        inputs=None,
+        outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, duration, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume, preset, vram_status]
+    )
+    log_btn.click(
+        get_latest_log,
+        inputs=None,
+        outputs=log_output
+    )
+
+# Launch locally without OpenAPI/docs
+logger.info("Launching Gradio UI at http://localhost:9999...")
+app = demo.launch(
+    server_name="0.0.0.0",
+    server_port=9999,
+    share=False,
+    inbrowser=False,
+    show_error=True
+)
+try:
+    fastapi_app = demo._server.app
+    fastapi_app.docs_url = None
+    fastapi_app.redoc_url = None
+    fastapi_app.openapi_url = None
+except Exception as e:
+    logger.error(f"Failed to configure FastAPI app: {e}")