import os import torch 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 from torch.cuda.amp import autocast import warnings import random import traceback import logging from datetime import datetime from pathlib import Path import mmap import subprocess import re import io # Suppress warnings for cleaner output warnings.filterwarnings("ignore") # Set PYTORCH_CUDA_ALLOC_CONF for CUDA 12 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:64" # Optimize for CUDA 12 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_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) ] ) logger = logging.getLogger(__name__) # 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) logger.info(f"Using GPU: {torch.cuda.get_device_name(0)} (CUDA 12)") logger.info(f"Using precision: float16 for model, float32 for CPU processing") # Memory cleanup function def clean_memory(): try: torch.cuda.empty_cache() gc.collect() torch.cuda.ipc_collect() torch.cuda.synchronize() vram_mb = torch.cuda.memory_allocated() / 1024**2 logger.info(f"Memory cleaned: VRAM allocated = {vram_mb:.2f} MB") logger.debug(f"VRAM summary: {torch.cuda.memory_summary()}") return vram_mb except Exception as e: logger.error(f"Failed to clean memory: {e}") logger.error(traceback.format_exc()) return None # Check VRAM and external processes def check_vram(): try: result = subprocess.run(['nvidia-smi', '--query-gpu=memory.used,memory.total', '--format=csv'], capture_output=True, text=True) lines = result.stdout.splitlines() if len(lines) > 1: used_mb, total_mb = map(int, re.findall(r'\d+', lines[1])) free_mb = total_mb - used_mb logger.info(f"VRAM: {used_mb} MiB used, {free_mb} MiB free, {total_mb} MiB total") if free_mb < 5000: # Warn if <5 GiB free logger.warning(f"Low free VRAM ({free_mb} MiB). Close other applications or processes.") result = subprocess.run(['nvidia-smi', '--query-compute-apps=pid,used_memory', '--format=csv'], capture_output=True, text=True) logger.info(f"GPU processes:\n{result.stdout}") return free_mb except Exception as e: logger.error(f"Failed to check VRAM: {e}") return None # Pre-run VRAM check and cleanup free_vram = check_vram() if free_vram is not None and free_vram < 5000: logger.warning("Consider terminating high-VRAM processes before continuing.") clean_memory() # Load MusicGen medium model into VRAM try: logger.info("Loading MusicGen medium model into VRAM...") local_model_path = "./models/musicgen-medium" if not os.path.exists(local_model_path): logger.error(f"Local model path {local_model_path} does not exist.") logger.error("Please download the MusicGen medium model weights and place them in the correct directory.") sys.exit(1) with autocast(dtype=torch.float16): musicgen_model = MusicGen.get_pretrained(local_model_path, device=device) musicgen_model.set_generation_params( duration=30, # Strict 30s max per chunk two_step_cfg=False ) logger.info("MusicGen medium model loaded successfully.") except Exception as e: logger.error(f"Failed to load MusicGen model: {e}") logger.error(traceback.format_exc()) sys.exit(1) # Check disk space def check_disk_space(path="."): try: stat = os.statvfs(path) free_space = stat.f_bavail * stat.f_frsize / (1024**3) # Free space in GB 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 except Exception as e: logger.error(f"Failed to check disk space: {e}") return False # Audio processing functions (CPU-based) def ensure_stereo(audio_segment, sample_rate=16000, sample_width=2): """Ensure the audio segment is stereo (2 channels).""" try: if audio_segment.channels != 2: logger.debug(f"Converting to stereo: {audio_segment.channels} channels detected") audio_segment = audio_segment.set_channels(2) return audio_segment except Exception as e: logger.error(f"Failed to ensure stereo: {e}") logger.error(traceback.format_exc()) return audio_segment def balance_stereo(audio_segment, noise_threshold=-60, sample_rate=16000): logger.debug(f"Balancing stereo for segment with sample rate {sample_rate}") try: audio_segment = ensure_stereo(audio_segment, sample_rate, audio_segment.sample_width) samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32) if audio_segment.channels == 2: stereo_samples = samples.reshape(-1, 2) db_samples = 20 * np.log10(np.abs(stereo_samples) + 1e-10) mask = db_samples > noise_threshold stereo_samples = stereo_samples * mask left_nonzero = stereo_samples[:, 0][stereo_samples[:, 0] != 0] right_nonzero = stereo_samples[:, 1][stereo_samples[:, 1] != 0] left_rms = np.sqrt(np.mean(left_nonzero**2)) if len(left_nonzero) > 0 else 0 right_rms = np.sqrt(np.mean(right_nonzero**2)) if len(right_nonzero) > 0 else 0 if left_rms > 0 and right_rms > 0: avg_rms = (left_rms + right_rms) / 2 stereo_samples[:, 0] = stereo_samples[:, 0] * (avg_rms / left_rms) stereo_samples[:, 1] = stereo_samples[:, 1] * (avg_rms / right_rms) balanced_samples = stereo_samples.flatten().astype(np.int32 if audio_segment.sample_width == 3 else np.int16) # Ensure sample length is even for stereo if len(balanced_samples) % 2 != 0: balanced_samples = balanced_samples[:-1] 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.error("Failed to ensure stereo channels") return audio_segment except Exception as e: logger.error(f"Failed to balance stereo: {e}") logger.error(traceback.format_exc()) return audio_segment def calculate_rms(segment): try: samples = np.array(segment.get_array_of_samples(), dtype=np.float32) rms = np.sqrt(np.mean(samples**2)) logger.debug(f"Calculated RMS: {rms}") return rms except Exception as e: logger.error(f"Failed to calculate RMS: {e}") logger.error(traceback.format_exc()) return 0 def rms_normalize(segment, target_rms_db=-23.0, peak_limit_db=-3.0, sample_rate=16000): logger.debug(f"Normalizing RMS for segment with target {target_rms_db} dBFS") try: segment = ensure_stereo(segment, sample_rate, segment.sample_width) target_rms = 10 ** (target_rms_db / 20) * (2**23 if segment.sample_width == 3 else 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 except Exception as e: logger.error(f"Failed to normalize RMS: {e}") logger.error(traceback.format_exc()) return segment def hard_limit(audio_segment, limit_db=-3.0, sample_rate=16000): logger.debug(f"Applying hard limit at {limit_db} dBFS") try: audio_segment = ensure_stereo(audio_segment, sample_rate, audio_segment.sample_width) limit = 10 ** (limit_db / 20.0) * (2**23 if audio_segment.sample_width == 3 else 32767) samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32) samples = np.clip(samples, -limit, limit).astype(np.int32 if audio_segment.sample_width == 3 else np.int16) # Ensure sample length is even for stereo if len(samples) % 2 != 0: samples = samples[:-1] limited_segment = AudioSegment( samples.tobytes(), frame_rate=sample_rate, sample_width=audio_segment.sample_width, channels=2 ) logger.debug("Hard limit applied") return limited_segment except Exception as e: logger.error(f"Failed to apply hard limit: {e}") logger.error(traceback.format_exc()) return audio_segment def apply_eq(segment, sample_rate=16000): logger.debug(f"Applying EQ with sample rate {sample_rate}") try: segment = ensure_stereo(segment, sample_rate, segment.sample_width) segment = segment.high_pass_filter(20) segment = segment.low_pass_filter(20000) logger.debug("EQ applied") return segment except Exception as e: logger.error(f"Failed to apply EQ: {e}") logger.error(traceback.format_exc()) 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") try: segment = ensure_stereo(segment, segment.frame_rate, segment.sample_width) segment = segment.fade_in(fade_in_duration) segment = segment.fade_out(fade_out_duration) logger.debug("Fade applied") return segment except Exception as e: logger.error(f"Failed to apply fade: {e}") logger.error(traceback.format_exc()) return segment # Genre prompt functions def set_red_hot_chili_peppers_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: rhythm = f" with {rhythmic_steps}" if rhythmic_steps != "none" else ("syncopated funk rhythms" if bpm > 120 else "groovy funk flow") drum = f", {drum_beat} drums" if drum_beat != "none" else ", tight funk drums with punchy snares" synth = f", {synthesizer} accents" if synthesizer != "none" else "" bass = f", {bass_style}" if bass_style != "none" else ", prominent slap bass with funky grooves" guitar = f", {guitar_style} guitar riffs" if guitar_style != "none" else ", syncopated funk guitar riffs with clean and distorted tones" prompt = ( f"Instrumental funk rock{bass}{guitar}{drum}{synth}, Red Hot Chili Peppers-inspired vibe with high-energy slap bass, " f"syncopated guitar riffs, dynamic breakdowns, and a raw, funky edge, {rhythm} at {bpm} BPM." ) logger.debug(f"Generated RHCP prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate RHCP prompt: {e}") logger.error(traceback.format_exc()) return "" def set_nirvana_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental grunge{bass}{guitar}{drum}{synth}, Nirvana-inspired angst-filled sound with quiet-loud dynamics, {rhythm} at {bpm} BPM." logger.debug(f"Generated Nirvana prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Nirvana prompt: {e}") logger.error(traceback.format_exc()) return "" def set_pearl_jam_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental grunge{bass}{guitar}{drum}{synth}, Pearl Jam-inspired emotional intensity with soaring choruses, {rhythm} at {bpm} BPM." logger.debug(f"Generated Pearl Jam prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Pearl Jam prompt: {e}") logger.error(traceback.format_exc()) return "" def set_soundgarden_grunge_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental grunge{bass}{guitar}{drum}{synth}, Soundgarden-inspired dark, psychedelic edge, {rhythm} at {bpm} BPM." logger.debug(f"Generated Soundgarden prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Soundgarden prompt: {e}") logger.error(traceback.format_exc()) return "" def set_foo_fighters_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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 = 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 f", {style} guitar riffs" prompt = f"Instrumental alternative rock{bass}{guitar}{drum}{synth}, Foo Fighters-inspired {mood} vibe with powerful choruses, {rhythm} at {bpm} BPM." logger.debug(f"Generated Foo Fighters prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Foo Fighters prompt: {e}") logger.error(traceback.format_exc()) return "" def set_smashing_pumpkins_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental alternative rock{bass}{guitar}{drum}{synth}, Smashing Pumpkins-inspired blend of melancholy and aggression, {rhythm} at {bpm} BPM." logger.debug(f"Generated Smashing Pumpkins prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Smashing Pumpkins prompt: {e}") logger.error(traceback.format_exc()) return "" def set_radiohead_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental experimental rock{bass}{guitar}{drum}{synth}, Radiohead-inspired blend of introspective and innovative soundscapes, {rhythm} at {bpm} BPM." logger.debug(f"Generated Radiohead prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Radiohead prompt: {e}") logger.error(traceback.format_exc()) return "" def set_classic_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental classic rock{bass}{guitar}{drum}{synth}, Led Zeppelin-inspired raw energy with dynamic solos, {rhythm} at {bpm} BPM." logger.debug(f"Generated Classic Rock prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Classic Rock prompt: {e}") logger.error(traceback.format_exc()) return "" def set_alternative_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental alternative rock{bass}{guitar}{drum}{synth}, Pixies-inspired quirky, energetic vibe, {rhythm} at {bpm} BPM." logger.debug(f"Generated Alternative Rock prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Alternative Rock prompt: {e}") logger.error(traceback.format_exc()) return "" def set_post_punk_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental post-punk{bass}{guitar}{drum}{synth}, Joy Division-inspired moody, atmospheric sound with a steady, hypnotic beat, {rhythm} at {bpm} BPM." logger.debug(f"Generated Post-Punk prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Post-Punk prompt: {e}") logger.error(traceback.format_exc()) return "" def set_indie_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental indie rock{bass}{guitar}{drum}{synth}, Arctic Monkeys-inspired blend of catchy riffs, {rhythm} at {bpm} BPM." logger.debug(f"Generated Indie Rock prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Indie Rock prompt: {e}") logger.error(traceback.format_exc()) return "" def set_funk_rock_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" prompt = f"Instrumental funk rock{bass}{guitar}{drum}{synth}, Rage Against the Machine-inspired mix of groove and aggression, {rhythm} at {bpm} BPM." logger.debug(f"Generated Funk Rock prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Funk Rock prompt: {e}") logger.error(traceback.format_exc()) return "" def set_detroit_techno_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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 a steady four-on-the-floor kick drum" synth = f", {synthesizer} accents" if synthesizer != "none" else ", deep pulsing synths with a repetitive, hypnotic pattern" bass = f", {bass_style}" if bass_style != "none" else ", driving basslines with a consistent, groovy pulse" guitar = f", {guitar_style} guitars" if guitar_style != "none" else "" prompt = f"Instrumental Detroit techno{bass}{guitar}{drum}{synth}, Juan Atkins-inspired rhythmic groove with a steady, repetitive beat, {rhythm} at {bpm} BPM." logger.debug(f"Generated Detroit Techno prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Detroit Techno prompt: {e}") logger.error(traceback.format_exc()) return "" def set_deep_house_prompt(bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style): try: 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" synth = f", {synthesizer} accents" if synthesizer != "none" else ", warm analog synth chords with a repetitive, hypnotic progression" bass = f", {bass_style}" if bass_style != "none" else ", deep basslines with a consistent, groovy pulse" guitar = f", {guitar_style} guitars" if guitar_style != "none" else "" prompt = f"Instrumental deep house{bass}{guitar}{drum}{synth}, Larry Heard-inspired laid-back groove with a steady, repetitive beat, {rhythm} at {bpm} BPM." logger.debug(f"Generated Deep House prompt: {prompt}") return prompt except Exception as e: logger.error(f"Failed to generate Deep House prompt: {e}") logger.error(traceback.format_exc()) return "" # Preset configurations for genres (optimized for medium model) PRESETS = { "default": {"cfg_scale": 1.8, "top_k": 120, "top_p": 0.9, "temperature": 0.8}, "rock": {"cfg_scale": 2.0, "top_k": 110, "top_p": 0.9, "temperature": 0.9}, "techno": {"cfg_scale": 1.5, "top_k": 130, "top_p": 0.85, "temperature": 0.7}, "grunge": {"cfg_scale": 1.8, "top_k": 120, "top_p": 0.9, "temperature": 0.85}, "indie": {"cfg_scale": 1.9, "top_k": 115, "top_p": 0.9, "temperature": 0.8}, "funk_rock": {"cfg_scale": 2.2, "top_k": 150, "top_p": 0.95, "temperature": 1.0} # Enhanced for RHCP } # Function to get the latest log file def get_latest_log(): try: 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." 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: {e}") logger.error(traceback.format_exc()) return f"Error reading log file: {e}" # Bitrate selection functions def set_bitrate_128(): logger.info("Bitrate set to 128 kbps") return "128k" def set_bitrate_192(): logger.info("Bitrate set to 192 kbps") return "192k" def set_bitrate_320(): logger.info("Bitrate set to 320 kbps") return "320k" # Sampling rate selection functions def set_sample_rate_22050(): logger.info("Output sampling rate set to 22.05 kHz") return "22050" def set_sample_rate_44100(): logger.info("Output sampling rate set to 44.1 kHz") return "44100" def set_sample_rate_48000(): logger.info("Output sampling rate set to 48 kHz") return "48000" # Bit depth selection functions def set_bit_depth_16(): logger.info("Bit depth set to 16-bit") return "16" def set_bit_depth_24(): logger.info("Bit depth set to 24-bit") return "24" # Optimized generation function def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p: float, temperature: float, total_duration: int, bpm: int, drum_beat: str, synthesizer: str, rhythmic_steps: str, bass_style: str, guitar_style: str, target_volume: float, preset: str, max_steps: str, vram_status: str, bitrate: str, output_sample_rate: str, bit_depth: str, seed: int): 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() # Convert max_steps to integer try: max_steps_int = int(max_steps) except ValueError: logger.error(f"Invalid max_steps value: {max_steps}") return None, "❌ Invalid max_steps value; must be a number (1000, 1200, 1300, or 1500)", vram_status # Convert output_sample_rate to integer try: output_sample_rate_int = int(output_sample_rate) except ValueError: logger.error(f"Invalid output_sample_rate value: {output_sample_rate}") return None, "❌ Invalid output sampling rate; must be a number (22050, 32000, 44100, or 48000)", vram_status # Convert bit_depth to integer and set sample_width try: bit_depth_int = int(bit_depth) sample_width = 3 if bit_depth_int == 24 else 2 except ValueError: logger.error(f"Invalid bit_depth value: {bit_depth}") return None, "❌ Invalid bit depth; must be 16 or 24", vram_status # Validate seed if not (0 <= seed <= 10000): logger.error(f"Invalid seed value: {seed}. Must be between 0 and 10000.") return None, "❌ Invalid seed value; must be between 0 and 10000", vram_status max_duration = min(max_steps_int / 50, 30) # Convert steps to seconds, cap at 30s total_duration = min(max(total_duration, 30), 120) # Clamp between 30s and 120s processing_sample_rate = 16000 # Fixed for processing channels = 2 # Enforce stereo audio_segments = [] overlap_duration = 0.2 # 200ms for continuation and crossfade remaining_duration = total_duration 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}") if not check_disk_space(): logger.error("Insufficient disk space") return None, "⚠️ Insufficient disk space. Free up at least 1 GB.", vram_status logger.info(f"Generating audio for {total_duration}s with seed={seed}, max_steps={max_steps_int}, output_sample_rate={output_sample_rate_int} Hz, bit_depth={bit_depth_int}-bit") base_prompt = instrumental_prompt clean_memory() vram_status = f"Initial VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB" while remaining_duration > 0: current_duration = min(max_duration, remaining_duration) generation_duration = current_duration # No overlap in generation chunk_num = len(audio_segments) + 1 logger.info(f"Generating chunk {chunk_num} ({current_duration}s, VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB)") musicgen_model.set_generation_params( duration=generation_duration, use_sampling=True, top_k=top_k, top_p=top_p, temperature=temperature, cfg_coef=cfg_scale ) try: with torch.no_grad(): with autocast(dtype=torch.float16): torch.manual_seed(seed) np.random.seed(seed) torch.cuda.manual_seed_all(seed) clean_memory() # Pre-generation cleanup if not audio_segments: logger.debug("Generating first chunk") audio_segment = musicgen_model.generate([base_prompt], progress=True)[0].cpu() else: logger.debug("Generating continuation chunk") prev_segment = audio_segments[-1] prev_segment = balance_stereo(prev_segment, noise_threshold=-60, sample_rate=processing_sample_rate) temp_wav_path = f"temp_prev_{int(time.time()*1000)}.wav" logger.debug(f"Exporting previous segment to {temp_wav_path}") prev_segment.export(temp_wav_path, format="wav") # Use memory-mapped file I/O with open(temp_wav_path, "rb") as f: mmapped_file = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) prev_audio, prev_sr = torchaudio.load(temp_wav_path) mmapped_file.close() if prev_sr != processing_sample_rate: logger.debug(f"Resampling from {prev_sr} to {processing_sample_rate}") prev_audio = torchaudio.transforms.Resample(prev_sr, processing_sample_rate)(prev_audio) if prev_audio.shape[0] != 2: logger.debug(f"Converting to stereo: {prev_audio.shape[0]} channels detected") prev_audio = prev_audio.repeat(2, 1)[:, :prev_audio.shape[1]] prev_audio = prev_audio.to(device) os.remove(temp_wav_path) logger.debug(f"Deleted temporary file {temp_wav_path}") audio_segment = musicgen_model.generate_continuation( prompt=prev_audio[:, -int(processing_sample_rate * overlap_duration):], prompt_sample_rate=processing_sample_rate, descriptions=[base_prompt], progress=True )[0].cpu() del prev_audio clean_memory() except Exception as e: logger.error(f"Error in chunk {chunk_num} generation: {e}") logger.error(traceback.format_exc()) return None, f"❌ Failed to generate chunk {chunk_num}: {e}", vram_status logger.debug(f"Generated audio segment shape: {audio_segment.shape}, dtype: {audio_segment.dtype}") # Perform stereo conversion on CPU with NumPy try: audio_np = audio_segment.numpy() if audio_np.ndim == 1: logger.debug("Converting mono to stereo on CPU") audio_np = np.stack([audio_np, audio_np], axis=0) elif audio_np.ndim == 2 and audio_np.shape[0] != 2: logger.debug(f"Adjusting to stereo on CPU: {audio_np.shape[0]} channels detected") audio_np = np.concatenate([audio_np, audio_np], axis=0)[:2] if audio_np.shape[0] != 2: logger.error(f"Expected stereo audio with shape (2, samples), got shape {audio_np.shape}") return None, f"❌ Invalid audio shape for chunk {chunk_num}: {audio_np.shape}", vram_status audio_segment = torch.from_numpy(audio_np).to(dtype=torch.float16) logger.debug(f"Converted audio segment to float16, shape: {audio_segment.shape}") except Exception as e: logger.error(f"Failed to process audio segment for chunk {chunk_num}: {e}") logger.error(traceback.format_exc()) return None, f"❌ Failed to process audio for chunk {chunk_num}: {e}", vram_status temp_wav_path = f"temp_audio_{int(time.time()*1000)}.wav" logger.debug(f"Saving audio segment to {temp_wav_path}, VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB") try: # Convert to float32 for torchaudio.save audio_segment_save = audio_segment.to(dtype=torch.float32) torchaudio.save(temp_wav_path, audio_segment_save, output_sample_rate_int, bits_per_sample=bit_depth_int) del audio_segment_save except Exception as e: logger.error(f"Failed to save audio segment for chunk {chunk_num}: {e}") logger.error(traceback.format_exc()) logger.warning(f"Skipping chunk {chunk_num} due to save error") del audio_segment clean_memory() continue clean_memory() try: with open(temp_wav_path, "rb") as f: mmapped_file = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) segment = AudioSegment.from_wav(temp_wav_path) mmapped_file.close() os.remove(temp_wav_path) logger.debug(f"Deleted temporary file {temp_wav_path}") except Exception as e: logger.error(f"Failed to load WAV file for chunk {chunk_num}: {e}") logger.error(traceback.format_exc()) logger.warning(f"Skipping chunk {chunk_num} due to WAV load error") del audio_segment clean_memory() continue try: segment = ensure_stereo(segment, processing_sample_rate, sample_width) segment = segment - 15 if segment.frame_rate != processing_sample_rate: logger.debug(f"Setting segment sample rate to {processing_sample_rate}") segment = segment.set_frame_rate(processing_sample_rate) segment = balance_stereo(segment, noise_threshold=-60, sample_rate=processing_sample_rate) segment = rms_normalize(segment, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=processing_sample_rate) segment = apply_eq(segment, sample_rate=processing_sample_rate) audio_segments.append(segment) except Exception as e: logger.error(f"Failed to process audio segment for chunk {chunk_num}: {e}") logger.error(traceback.format_exc()) logger.warning(f"Skipping chunk {chunk_num} due to processing error") del audio_segment clean_memory() continue del audio_segment del audio_np clean_memory() vram_status = f"VRAM after chunk {chunk_num}: {torch.cuda.memory_allocated() / 1024**2:.2f} MB" time.sleep(0.1) remaining_duration -= current_duration if not audio_segments: logger.error("No audio segments generated") return None, "❌ No audio segments generated due to errors", vram_status logger.info("Combining audio chunks...") try: final_segment = audio_segments[0][:min(max_duration, total_duration) * 1000] final_segment = ensure_stereo(final_segment, processing_sample_rate, sample_width) overlap_ms = int(overlap_duration * 1000) for i in range(1, len(audio_segments)): current_segment = audio_segments[i] current_segment = current_segment[:min(max_duration, total_duration - (i * max_duration)) * 1000] current_segment = ensure_stereo(current_segment, processing_sample_rate, sample_width) if overlap_ms > 0 and len(current_segment) > overlap_ms: logger.debug(f"Applying crossfade between chunks {i} and {i+1}") prev_overlap = final_segment[-overlap_ms:] curr_overlap = current_segment[:overlap_ms] # Use torchaudio for precise crossfading prev_audio, _ = torchaudio.load(io.BytesIO(prev_overlap.raw_data)) curr_audio, _ = torchaudio.load(io.BytesIO(curr_overlap.raw_data)) num_samples = min(prev_audio.shape[1], curr_audio.shape[1]) # Ensure num_samples is even for stereo num_samples = num_samples - (num_samples % 2) if num_samples <= 0: logger.warning(f"Skipping crossfade for chunk {i+1} due to insufficient samples") final_segment += current_segment continue blended_samples = torch.zeros(2, num_samples, dtype=torch.float32) prev_samples = prev_audio[:, :num_samples] curr_samples = curr_audio[:, :num_samples] hann_window = torch.hann_window(num_samples, periodic=False) fade_out = hann_window.flip(0) fade_in = hann_window blended_samples = (prev_samples * fade_out + curr_samples * fade_in) # Convert to appropriate dtype for bit depth blended_samples = (blended_samples * (2**23 if sample_width == 3 else 32767)).to(torch.int32 if sample_width == 3 else torch.int16) # Save to temporary WAV to create AudioSegment temp_crossfade_path = f"temp_crossfade_{int(time.time()*1000)}.wav" torchaudio.save(temp_crossfade_path, blended_samples, processing_sample_rate, bits_per_sample=bit_depth_int) blended_segment = AudioSegment.from_wav(temp_crossfade_path) os.remove(temp_crossfade_path) blended_segment = ensure_stereo(blended_segment, processing_sample_rate, sample_width) blended_segment = rms_normalize(blended_segment, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=processing_sample_rate) final_segment = final_segment[:-overlap_ms] + blended_segment + current_segment[overlap_ms:] else: logger.debug(f"Concatenating chunk {i+1} without crossfade") final_segment += current_segment final_segment = final_segment[:total_duration * 1000] logger.info("Post-processing final track...") final_segment = rms_normalize(final_segment, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=processing_sample_rate) final_segment = apply_eq(final_segment, sample_rate=processing_sample_rate) final_segment = apply_fade(final_segment) final_segment = balance_stereo(final_segment, noise_threshold=-60, sample_rate=processing_sample_rate) final_segment = final_segment - 10 final_segment = final_segment.set_frame_rate(output_sample_rate_int) # Set to selected output rate 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: clean_memory() # Pre-export cleanup logger.debug(f"Exporting final audio to {mp3_path} with bitrate {bitrate}, sample rate {output_sample_rate_int} Hz, bit depth {bit_depth_int}-bit") final_segment.export( mp3_path, format="mp3", bitrate=bitrate, tags={"title": "GhostAI Instrumental", "artist": "GhostAI"} ) logger.info(f"Final audio saved to {mp3_path}") except Exception as e: logger.error(f"Error exporting MP3 with bitrate {bitrate}: {e}") logger.error(traceback.format_exc()) fallback_path = f"fallback_output_{int(time.time())}.mp3" try: final_segment.export(fallback_path, format="mp3", bitrate="128k") logger.info(f"Final audio saved to fallback: {fallback_path} with 128 kbps") mp3_path = fallback_path except Exception as fallback_e: logger.error(f"Failed to save fallback MP3: {fallback_e}") return None, f"❌ Failed to export audio: {fallback_e}", vram_status vram_status = f"Final VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB" logger.info(f"Generation completed in {time.time() - start_time:.2f} seconds") return mp3_path, "✅ Done! Generated track with adjusted volume levels. Check for static in Audacity.", vram_status except Exception as e: logger.error(f"Failed to combine audio chunks: {e}") logger.error(traceback.format_exc()) return None, f"❌ Failed to combine audio: {e}", 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 finally: clean_memory() # Clear inputs function def clear_inputs(): logger.info("Clearing input fields") return "", 1.8, 120, 0.9, 0.8, 30, 120, "none", "none", "none", "none", "none", -23.0, "default", 1300, "96k", "32000", "16", 0 # Custom CSS css = """ 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, .bitrate-buttons, .sample-rate-buttons, .bit-depth-buttons { display: flex; justify-content: center; flex-wrap: wrap; gap: 15px; } .genre-btn, .bitrate-btn, .sample-rate-btn, .bit-depth-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 🎹

Summon the Sound of the Unknown

""") 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=1.8, 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=120, 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." ) total_duration = gr.Dropdown( label="Song Length ⏳ (seconds)", choices=[30, 60, 90, 120], value=30, info="Select the total duration of the track." ) 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", "funk_rock"], value="default", info="Select a preset optimized for specific genres." ) max_steps = gr.Dropdown( label="Max Steps per Chunk 📏", choices=[1000, 1200, 1300, 1500], value=1300, info="Number of generation steps per chunk (1000=~20s, 1500=~30s)." ) seed = gr.Slider( label="Random Seed 🌱", minimum=0, maximum=10000, value=0, step=1, info="Set a seed for reproducibility (0-10000). Change for different variations." ) bitrate_state = gr.State(value="96k") # Default bitrate sample_rate_state = gr.State(value="32000") # Default output sampling rate bit_depth_state = gr.State(value="16") # Default bit depth with gr.Row(elem_classes="bitrate-buttons"): bitrate_128_btn = gr.Button("Set Bitrate to 128 kbps", elem_classes="bitrate-btn") bitrate_192_btn = gr.Button("Set Bitrate to 192 kbps", elem_classes="bitrate-btn") bitrate_320_btn = gr.Button("Set Bitrate to 320 kbps", elem_classes="bitrate-btn") with gr.Row(elem_classes="sample-rate-buttons"): sample_rate_22050_btn = gr.Button("Set Sampling Rate to 22.05 kHz", elem_classes="sample-rate-btn") sample_rate_44100_btn = gr.Button("Set Sampling Rate to 44.1 kHz", elem_classes="sample-rate-btn") sample_rate_48000_btn = gr.Button("Set Sampling Rate to 48 kHz", elem_classes="sample-rate-btn") with gr.Row(elem_classes="bit-depth-buttons"): bit_depth_16_btn = gr.Button("Set Bit Depth to 16-bit", elem_classes="bit-depth-btn") bit_depth_24_btn = gr.Button("Set Bit Depth to 24-bit", elem_classes="bit-depth-btn") 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], outputs=instrumental_prompt) nirvana_btn.click(set_nirvana_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) pearl_jam_btn.click(set_pearl_jam_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) soundgarden_btn.click(set_soundgarden_grunge_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) foo_fighters_btn.click(set_foo_fighters_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) smashing_pumpkins_btn.click(set_smashing_pumpkins_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) radiohead_btn.click(set_radiohead_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) classic_rock_btn.click(set_classic_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) alternative_rock_btn.click(set_alternative_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) post_punk_btn.click(set_post_punk_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) indie_rock_btn.click(set_indie_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) funk_rock_btn.click(set_funk_rock_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) detroit_techno_btn.click(set_detroit_techno_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) deep_house_btn.click(set_deep_house_prompt, inputs=[bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style], outputs=instrumental_prompt) bitrate_128_btn.click(set_bitrate_128, inputs=None, outputs=bitrate_state) bitrate_192_btn.click(set_bitrate_192, inputs=None, outputs=bitrate_state) bitrate_320_btn.click(set_bitrate_320, inputs=None, outputs=bitrate_state) sample_rate_22050_btn.click(set_sample_rate_22050, inputs=None, outputs=sample_rate_state) sample_rate_44100_btn.click(set_sample_rate_44100, inputs=None, outputs=sample_rate_state) sample_rate_48000_btn.click(set_sample_rate_48000, inputs=None, outputs=sample_rate_state) bit_depth_16_btn.click(set_bit_depth_16, inputs=None, outputs=bit_depth_state) bit_depth_24_btn.click(set_bit_depth_24, inputs=None, outputs=bit_depth_state) gen_btn.click( generate_music, inputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume, preset, max_steps, vram_status, bitrate_state, sample_rate_state, bit_depth_state, seed], outputs=[out_audio, status, vram_status] ) clr_btn.click( clear_inputs, inputs=None, outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume, preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, seed] ) 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...") try: app = demo.launch( server_name="0.0.0.0", server_port=9999, share=False, # Set to False for local deployment 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}") except Exception as e: logger.error(f"Failed to launch Gradio UI: {e}") logger.error(traceback.format_exc()) sys.exit(1)