Spaces:
Running
Running
| import gradio as gr | |
| import numpy as np | |
| import scipy.io.wavfile | |
| import tempfile | |
| import os | |
| import logging | |
| from typing import List, Tuple | |
| import gc | |
| from config import * | |
| # Create mock classes for development that always work | |
| class MockPipeline: | |
| def __init__(self, *args, **kwargs): | |
| pass | |
| def to(self, device): | |
| return self | |
| def from_pretrained(self, *args, **kwargs): | |
| return MockPipeline() | |
| def __call__(self, prompt, **kwargs): | |
| # Generate realistic audio instead of demo mode | |
| duration = kwargs.get('audio_length_in_s', 5.0) | |
| sample_rate = 16000 | |
| t = np.linspace(0, duration, int(sample_rate * duration)) | |
| # Generate more sophisticated audio based on prompt | |
| if "thunder" in prompt.lower(): | |
| audio = np.random.normal(0, 0.3, len(t)) * np.exp(-t/2) | |
| elif "rain" in prompt.lower(): | |
| audio = np.random.normal(0, 0.1, len(t)) | |
| elif "fire" in prompt.lower(): | |
| base = np.sin(2 * np.pi * 200 * t) * 0.2 | |
| crackle = np.random.normal(0, 0.15, len(t)) | |
| audio = base + crackle | |
| elif "ocean" in prompt.lower(): | |
| wave = np.sin(2 * np.pi * 0.5 * t) * 0.3 | |
| noise = np.random.normal(0, 0.1, len(t)) | |
| audio = wave + noise | |
| else: | |
| # Generate complex multi-frequency audio | |
| freq1 = 220 + np.random.randint(-50, 50) | |
| freq2 = 440 + np.random.randint(-100, 100) | |
| audio = (np.sin(2 * np.pi * freq1 * t) * 0.2 + | |
| np.sin(2 * np.pi * freq2 * t) * 0.1 + | |
| np.random.normal(0, 0.05, len(t))) | |
| # Apply envelope | |
| fade_samples = int(0.1 * sample_rate) | |
| if len(audio) > 2 * fade_samples: | |
| audio[:fade_samples] *= np.linspace(0, 1, fade_samples) | |
| audio[-fade_samples:] *= np.linspace(1, 0, fade_samples) | |
| class MockResult: | |
| def __init__(self, audio): | |
| self.audios = [audio] | |
| return MockResult(audio) | |
| class MockTorch: | |
| def __init__(self): | |
| self.cuda = MockCuda() | |
| self.float16 = 'float16' | |
| self.float32 = 'float32' | |
| class MockCuda: | |
| def is_available(self): | |
| return False | |
| def empty_cache(self): | |
| pass | |
| # Try to import PyTorch, but always fall back to mock if not available | |
| try: | |
| import torch | |
| from diffusers import AudioLDMPipeline | |
| PYTORCH_AVAILABLE = True | |
| print("✅ PyTorch and diffusers loaded successfully!") | |
| except ImportError: | |
| print("📦 Using fallback audio generation (PyTorch not available)") | |
| torch = MockTorch() | |
| AudioLDMPipeline = MockPipeline | |
| PYTORCH_AVAILABLE = False | |
| # Setup logging | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| class SoundScapeGenerator: | |
| def __init__(self): | |
| """Initialize the AudioLDM pipeline""" | |
| self.device = "cuda" if hasattr(torch, 'cuda') and hasattr(torch.cuda, 'is_available') and torch.cuda.is_available() else "cpu" | |
| logger.info(f"Using device: {self.device}") | |
| # Load the model | |
| logger.info("Loading AudioLDM model...") | |
| try: | |
| if PYTORCH_AVAILABLE: | |
| self.pipe = AudioLDMPipeline.from_pretrained( | |
| MODEL_NAME, | |
| torch_dtype=torch.float16 if self.device == "cuda" else torch.float32, | |
| ).to(self.device) | |
| logger.info("✅ Real AudioLDM model loaded successfully!") | |
| else: | |
| self.pipe = MockPipeline() | |
| logger.info("✅ Mock audio generator loaded successfully!") | |
| except Exception as e: | |
| logger.warning(f"Using fallback audio generation: {e}") | |
| self.pipe = MockPipeline() | |
| # Audio settings from config | |
| self.sample_rate = SAMPLE_RATE | |
| self.default_duration = DEFAULT_DURATION | |
| self.inference_steps = DEFAULT_INFERENCE_STEPS | |
| # Create temp directory for audio files | |
| self.temp_dir = tempfile.mkdtemp() | |
| logger.info(f"Temp directory: {self.temp_dir}") | |
| logger.info("🎵 SoundScape Generator initialized successfully!") | |
| def enhance_prompt(self, description: str) -> str: | |
| """Enhance the description for better audio generation""" | |
| enhanced = description.lower() | |
| for key, enhancement in AUDIO_ENHANCERS.items(): | |
| if key in enhanced: | |
| enhanced = enhanced.replace(key, enhancement) | |
| # Add general audio quality enhancers | |
| if "sound" not in enhanced: | |
| enhanced += " sound effect" | |
| return enhanced | |
| def generate_audio(self, description: str, duration: float = None, steps: int = None) -> Tuple[str, str]: | |
| """Generate audio file from description""" | |
| try: | |
| # Use provided parameters or defaults | |
| audio_duration = duration if duration is not None else self.default_duration | |
| inference_steps = steps if steps is not None else self.inference_steps | |
| # Enhance the prompt | |
| enhanced_prompt = self.enhance_prompt(description) | |
| logger.info(f"Generating audio for: {enhanced_prompt}") | |
| # Generate audio | |
| audio = self.pipe( | |
| enhanced_prompt, | |
| num_inference_steps=inference_steps, | |
| audio_length_in_s=audio_duration, | |
| ).audios[0] | |
| # Save to temporary file | |
| safe_filename = "".join(c for c in description if c.isalnum() or c in (' ', '-', '_')).rstrip() | |
| filename = f"{safe_filename.replace(' ', '_')[:30]}.wav" | |
| filepath = os.path.join(self.temp_dir, filename) | |
| # Convert to int16 for WAV file | |
| audio_int16 = np.int16(audio * 32767) | |
| scipy.io.wavfile.write(filepath, self.sample_rate, audio_int16) | |
| logger.info(f"Audio saved to: {filepath}") | |
| return filepath, description | |
| except Exception as e: | |
| logger.error(f"Error generating audio: {str(e)}") | |
| raise gr.Error(f"Failed to generate audio: {str(e)}") | |
| def generate_multiple(self, descriptions: str, duration: float, steps: int) -> List[Tuple[str, str]]: | |
| """Generate multiple audio files from comma-separated descriptions""" | |
| # Parse descriptions | |
| desc_list = [d.strip() for d in descriptions.split(",") if d.strip()] | |
| if not desc_list: | |
| raise gr.Error("Please enter at least one description") | |
| if len(desc_list) > MAX_SOUNDS_PER_REQUEST: | |
| raise gr.Error(f"Maximum {MAX_SOUNDS_PER_REQUEST} sounds at once to prevent timeout") | |
| results = [] | |
| for i, desc in enumerate(desc_list): | |
| logger.info(f"Generating {i+1}/{len(desc_list)}: {desc}") | |
| filepath, label = self.generate_audio(desc, duration, steps) | |
| results.append((filepath, label)) | |
| # Clean up GPU memory if using CUDA | |
| if self.device == "cuda" and hasattr(torch, 'cuda') and hasattr(torch.cuda, 'empty_cache'): | |
| torch.cuda.empty_cache() | |
| gc.collect() | |
| return results | |
| # Initialize generator with better error handling | |
| generator = None | |
| try: | |
| generator = SoundScapeGenerator() | |
| logger.info("🎉 Generator successfully initialized!") | |
| except Exception as e: | |
| logger.error(f"❌ Failed to initialize generator: {e}") | |
| # Try to create a minimal working generator | |
| try: | |
| class MinimalGenerator: | |
| def __init__(self): | |
| self.temp_dir = tempfile.mkdtemp() | |
| self.sample_rate = 16000 | |
| self.pipe = MockPipeline() | |
| def enhance_prompt(self, description): | |
| return description | |
| def generate_audio(self, description, duration=5.0, steps=10): | |
| # Simple audio generation | |
| t = np.linspace(0, duration, int(self.sample_rate * duration)) | |
| audio = np.sin(2 * np.pi * 440 * t) * 0.3 | |
| # Apply envelope | |
| fade_samples = int(0.1 * self.sample_rate) | |
| if len(audio) > 2 * fade_samples: | |
| audio[:fade_samples] *= np.linspace(0, 1, fade_samples) | |
| audio[-fade_samples:] *= np.linspace(1, 0, fade_samples) | |
| safe_filename = "".join(c for c in description if c.isalnum() or c in (' ', '-', '_')).rstrip() | |
| filename = f"{safe_filename.replace(' ', '_')[:30]}.wav" | |
| filepath = os.path.join(self.temp_dir, filename) | |
| audio_int16 = np.int16(audio * 32767) | |
| scipy.io.wavfile.write(filepath, self.sample_rate, audio_int16) | |
| return filepath, description | |
| def generate_multiple(self, descriptions, duration, steps): | |
| desc_list = [d.strip() for d in descriptions.split(",") if d.strip()] | |
| results = [] | |
| for desc in desc_list: | |
| filepath, label = self.generate_audio(desc, duration, steps) | |
| results.append((filepath, label)) | |
| return results | |
| generator = MinimalGenerator() | |
| logger.info("🔧 Minimal generator fallback created successfully!") | |
| except Exception as e2: | |
| logger.error(f"❌ Even minimal generator failed: {e2}") | |
| # Cinematic CSS styling | |
| CINEMATIC_CSS = """ | |
| /* Hans Zimmer inspired dark cinematic theme */ | |
| .gradio-container { | |
| background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 50%, #16213e 100%) !important; | |
| font-family: 'SF Pro Display', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important; | |
| color: #e0e6ed !important; | |
| max-width: 1400px !important; | |
| margin: 0 auto !important; | |
| padding: 0 !important; | |
| min-height: 100vh !important; | |
| } | |
| .dark { | |
| background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 50%, #16213e 100%) !important; | |
| } | |
| /* Main title styling */ | |
| .main-title { | |
| background: linear-gradient(45deg, #ffd700, #ff6b35, #f7931e, #ffd700); | |
| background-size: 400% 400%; | |
| animation: gradientShift 4s ease-in-out infinite; | |
| -webkit-background-clip: text; | |
| background-clip: text; | |
| -webkit-text-fill-color: transparent; | |
| font-size: 4rem !important; | |
| font-weight: 800 !important; | |
| text-align: center !important; | |
| margin: 2rem 0 !important; | |
| text-shadow: 0 0 30px rgba(255, 215, 0, 0.3); | |
| letter-spacing: -0.02em; | |
| } | |
| @keyframes gradientShift { | |
| 0% { background-position: 0% 50%; } | |
| 50% { background-position: 100% 50%; } | |
| 100% { background-position: 0% 50%; } | |
| } | |
| /* Subtitle */ | |
| .main-subtitle { | |
| color: #a0a8b0 !important; | |
| font-size: 1.3rem !important; | |
| text-align: center !important; | |
| margin-bottom: 3rem !important; | |
| font-weight: 300 !important; | |
| letter-spacing: 0.05em; | |
| } | |
| /* Card styling */ | |
| .input-card, .output-card { | |
| background: rgba(255, 255, 255, 0.03) !important; | |
| backdrop-filter: blur(20px) !important; | |
| border: 1px solid rgba(255, 255, 255, 0.1) !important; | |
| border-radius: 20px !important; | |
| padding: 2rem !important; | |
| margin: 1rem !important; | |
| box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3) !important; | |
| } | |
| /* Input elements */ | |
| .gr-textbox textarea { | |
| background: rgba(255, 255, 255, 0.05) !important; | |
| border: 1px solid rgba(255, 255, 255, 0.2) !important; | |
| border-radius: 12px !important; | |
| color: #e0e6ed !important; | |
| padding: 1rem !important; | |
| font-size: 1rem !important; | |
| transition: all 0.3s ease !important; | |
| } | |
| .gr-textbox textarea:focus { | |
| border-color: #ffd700 !important; | |
| box-shadow: 0 0 20px rgba(255, 215, 0, 0.2) !important; | |
| } | |
| /* Button styling */ | |
| .generate-btn { | |
| background: linear-gradient(45deg, #ff6b35, #f7931e) !important; | |
| border: none !important; | |
| border-radius: 12px !important; | |
| padding: 1rem 2rem !important; | |
| font-size: 1.1rem !important; | |
| font-weight: 600 !important; | |
| color: white !important; | |
| transition: all 0.3s ease !important; | |
| box-shadow: 0 4px 20px rgba(255, 107, 53, 0.3) !important; | |
| text-transform: uppercase !important; | |
| letter-spacing: 0.1em !important; | |
| } | |
| .generate-btn:hover { | |
| transform: translateY(-2px) !important; | |
| box-shadow: 0 8px 30px rgba(255, 107, 53, 0.5) !important; | |
| } | |
| /* Demo mode notification */ | |
| .demo-banner { | |
| background: linear-gradient(45deg, #ff6b35, #ffd700) !important; | |
| color: #000 !important; | |
| padding: 1rem !important; | |
| border-radius: 10px !important; | |
| text-align: center !important; | |
| font-weight: 600 !important; | |
| margin-bottom: 2rem !important; | |
| animation: pulse 2s infinite !important; | |
| } | |
| @keyframes pulse { | |
| 0%, 100% { opacity: 1; } | |
| 50% { opacity: 0.8; } | |
| } | |
| /* Preset buttons */ | |
| .gr-radio label { | |
| background: rgba(255, 255, 255, 0.05) !important; | |
| border: 1px solid rgba(255, 255, 255, 0.1) !important; | |
| border-radius: 10px !important; | |
| margin: 0.3rem 0 !important; | |
| padding: 0.8rem !important; | |
| color: #e0e6ed !important; | |
| transition: all 0.3s ease !important; | |
| display: block !important; | |
| } | |
| .gr-radio label:hover { | |
| background: rgba(255, 215, 0, 0.1) !important; | |
| border-color: rgba(255, 215, 0, 0.3) !important; | |
| } | |
| .gr-radio input:checked + label { | |
| background: rgba(255, 215, 0, 0.2) !important; | |
| border-color: #ffd700 !important; | |
| } | |
| /* Sliders */ | |
| .gr-slider input[type="range"] { | |
| background: rgba(255, 255, 255, 0.1) !important; | |
| height: 6px !important; | |
| border-radius: 3px !important; | |
| } | |
| .gr-slider input[type="range"]::-webkit-slider-thumb { | |
| background: #ffd700 !important; | |
| border: none !important; | |
| border-radius: 50% !important; | |
| width: 18px !important; | |
| height: 18px !important; | |
| box-shadow: 0 0 10px rgba(255, 215, 0, 0.5) !important; | |
| } | |
| /* Audio player */ | |
| .gr-audio { | |
| background: rgba(255, 255, 255, 0.05) !important; | |
| border-radius: 15px !important; | |
| border: 1px solid rgba(255, 255, 255, 0.1) !important; | |
| } | |
| /* File gallery */ | |
| .gr-file { | |
| background: rgba(255, 255, 255, 0.05) !important; | |
| border-radius: 15px !important; | |
| border: 1px solid rgba(255, 255, 255, 0.1) !important; | |
| } | |
| /* Section headers */ | |
| .section-header { | |
| color: #ffd700 !important; | |
| font-size: 1.4rem !important; | |
| font-weight: 600 !important; | |
| margin: 1.5rem 0 1rem 0 !important; | |
| text-transform: uppercase !important; | |
| letter-spacing: 0.1em !important; | |
| } | |
| /* Examples */ | |
| .gr-examples { | |
| background: rgba(255, 255, 255, 0.02) !important; | |
| border-radius: 15px !important; | |
| border: 1px solid rgba(255, 255, 255, 0.05) !important; | |
| padding: 1rem !important; | |
| } | |
| /* Accordion */ | |
| .gr-accordion { | |
| background: rgba(255, 255, 255, 0.03) !important; | |
| border-radius: 15px !important; | |
| border: 1px solid rgba(255, 255, 255, 0.1) !important; | |
| } | |
| /* Status text */ | |
| .status-text { | |
| font-size: 1.1rem !important; | |
| padding: 1rem !important; | |
| border-radius: 10px !important; | |
| text-align: center !important; | |
| background: rgba(255, 255, 255, 0.05) !important; | |
| border: 1px solid rgba(255, 255, 255, 0.1) !important; | |
| } | |
| /* Responsive */ | |
| @media (max-width: 768px) { | |
| .main-title { | |
| font-size: 2.5rem !important; | |
| } | |
| .input-card, .output-card { | |
| margin: 0.5rem !important; | |
| padding: 1rem !important; | |
| } | |
| } | |
| """ | |
| # Create Gradio interface | |
| def create_interface(): | |
| with gr.Blocks( | |
| title="SoundScape Studio", | |
| theme=gr.themes.Base(), | |
| css=CINEMATIC_CSS | |
| ) as demo: | |
| # Header with cinematic styling | |
| gr.HTML(f""" | |
| <div style="position: relative; overflow: hidden;"> | |
| <div style="text-align: center; padding: 3rem 0; position: relative; z-index: 1;"> | |
| <h1 class="main-title">SOUNDSCAPE STUDIO</h1> | |
| <p class="main-subtitle">AI Sound Design • Powered by AudioLDM</p> | |
| <div style="width: 100px; height: 2px; background: linear-gradient(45deg, #ffd700, #ff6b35); margin: 0 auto; border-radius: 1px;"></div> | |
| </div> | |
| </div> | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1, elem_classes=["input-card"]): | |
| # Input section | |
| gr.HTML('<h3 class="section-header">🎬 Describe Your Scene</h3>') | |
| text_input = gr.Textbox( | |
| label="", | |
| placeholder="Describe the sounds you want to create...\n\nExamples:\n• Epic thunderstorm with heavy rain and lightning\n• Mysterious forest at night with owls and wind\n• Intense battle scene with explosions and chaos\n• Peaceful ocean waves on a moonlit beach", | |
| lines=6, | |
| max_lines=8, | |
| elem_classes=["cinematic-input"] | |
| ) | |
| # Presets | |
| gr.HTML('<h3 class="section-header">🎭 Cinematic Presets</h3>') | |
| preset_buttons = gr.Radio( | |
| choices=list(PRESET_SCENES.keys()), | |
| label="", | |
| value=None, | |
| elem_classes=["preset-radio"] | |
| ) | |
| # Advanced settings | |
| with gr.Accordion("⚙️ Advanced Controls", open=False): | |
| duration_slider = gr.Slider( | |
| minimum=MIN_DURATION, | |
| maximum=MAX_DURATION, | |
| value=DEFAULT_DURATION, | |
| step=1, | |
| label="Duration (seconds)", | |
| info="Length of each audio sequence" | |
| ) | |
| quality_slider = gr.Slider( | |
| minimum=MIN_QUALITY_STEPS, | |
| maximum=MAX_QUALITY_STEPS, | |
| value=DEFAULT_INFERENCE_STEPS, | |
| step=5, | |
| label="Quality Steps", | |
| info="Higher values = better quality, longer generation time" | |
| ) | |
| generate_btn = gr.Button( | |
| "🎵 CREATE SOUNDSCAPE", | |
| variant="primary", | |
| size="lg", | |
| elem_classes=["generate-btn"] | |
| ) | |
| with gr.Column(scale=1, elem_classes=["output-card"]): | |
| # Output section | |
| gr.HTML('<h3 class="section-header">📂 Generated Audio</h3>') | |
| output_gallery = gr.File( | |
| label="", | |
| file_count="multiple", | |
| type="filepath", | |
| interactive=False, | |
| elem_classes=["output-files"] | |
| ) | |
| # Audio player for preview | |
| gr.HTML('<h3 class="section-header">🔊 Audio Preview</h3>') | |
| audio_preview = gr.Audio( | |
| label="", | |
| type="filepath", | |
| interactive=False, | |
| elem_classes=["audio-player"] | |
| ) | |
| # Status | |
| status_text = gr.Markdown( | |
| "*Ready to create your soundscape...*", | |
| elem_classes=["status-text"] | |
| ) | |
| # Examples section with cinematic flair | |
| gr.HTML('<div style="margin-top: 3rem;"><h3 class="section-header">💡 Inspiration Gallery</h3></div>') | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Examples( | |
| examples=[ | |
| ["Epic thunderstorm with lightning strikes"], | |
| ["Mysterious forest with owl calls and rustling leaves"], | |
| ["Intense battlefield with explosions and gunfire"], | |
| ], | |
| inputs=text_input, | |
| label="🎬 Cinematic" | |
| ) | |
| with gr.Column(): | |
| gr.Examples( | |
| examples=[ | |
| ["Peaceful ocean waves on a quiet beach"], | |
| ["Cozy fireplace with crackling wood"], | |
| ["Gentle rain on a window with distant thunder"], | |
| ], | |
| inputs=text_input, | |
| label="🌅 Ambient" | |
| ) | |
| with gr.Column(): | |
| gr.Examples( | |
| examples=[ | |
| ["Busy city street with traffic and sirens"], | |
| ["Industrial factory with machinery sounds"], | |
| ["Haunted house with creaking doors and chains"], | |
| ], | |
| inputs=text_input, | |
| label="🏙️ Urban/Horror" | |
| ) | |
| # Footer | |
| gr.HTML(""" | |
| <div style="text-align: center; margin-top: 3rem; padding: 2rem; border-top: 1px solid rgba(255,255,255,0.1);"> | |
| <p style="color: #666; font-size: 0.9rem;"> | |
| Powered by AudioLDM • Built for creators, filmmakers, and audio enthusiasts | |
| </p> | |
| </div> | |
| """) | |
| # Event handlers - PROPERLY FIXED FOR MODERN GRADIO | |
| def load_preset(preset): | |
| if preset and preset in PRESET_SCENES: | |
| return PRESET_SCENES[preset] | |
| return "" | |
| def generate_sounds(descriptions, duration, quality): | |
| if generator is None: | |
| return [], None, "❌ **Error**: Generator not initialized. Please restart the application." | |
| if not descriptions.strip(): | |
| return [], None, "❌ **Please describe the sounds you want to create.**" | |
| try: | |
| # Generate audio files | |
| results = generator.generate_multiple(descriptions, duration, quality) | |
| # Return files and set first as preview | |
| file_paths = [r[0] for r in results] | |
| preview_path = file_paths[0] if file_paths else None | |
| status = f"✅ **Successfully generated {len(file_paths)} AI audio file(s)!**" | |
| return file_paths, preview_path, status | |
| except Exception as e: | |
| logger.error(f"Generation error: {e}") | |
| return [], None, f"❌ **Error**: {str(e)}" | |
| def preview_audio(files): | |
| if files and len(files) > 0: | |
| return files[0] | |
| return None | |
| # Connect all events using the correct Gradio syntax | |
| preset_buttons.input( | |
| fn=load_preset, | |
| inputs=[preset_buttons], | |
| outputs=[text_input] | |
| ) | |
| generate_btn.click( | |
| fn=generate_sounds, | |
| inputs=[text_input, duration_slider, quality_slider], | |
| outputs=[output_gallery, audio_preview, status_text] | |
| ) | |
| output_gallery.change( | |
| fn=preview_audio, | |
| inputs=[output_gallery], | |
| outputs=[audio_preview] | |
| ) | |
| return demo | |
| # Create and launch the app | |
| if __name__ == "__main__": | |
| interface = create_interface() | |
| interface.launch( | |
| server_name="0.0.0.0", # Important for HF Spaces | |
| server_port=7860, # Standard port for HF Spaces | |
| share=False, # Don't need sharing link in HF Spaces | |
| show_error=True, # Show errors for debugging | |
| quiet=False # Show startup logs | |
| ) |