Update app.py

app.py

@@ -1,8 +1,6 @@
+import gradio as gr
 import os
-import uuid
 import torch
-import numpy as np
-import gradio as gr
 from transformers import (
     AutoTokenizer,
     AutoModelForCausalLM,
@@ -15,23 +13,30 @@ from pydub import AudioSegment
 from dotenv import load_dotenv
 import tempfile
 import spaces
+
+# Coqui TTS
 from TTS.api import TTS
 
-# -----------------------------------------------------------
-# Initialization & Environment Setup
-# -----------------------------------------------------------
+# ---------------------------------------------------------------------
+# Load Environment Variables
+# ---------------------------------------------------------------------
 load_dotenv()
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-# -----------------------------------------------------------
-# Model Cache Management
-# -----------------------------------------------------------
+# ---------------------------------------------------------------------
+# Global Model Caches
+# ---------------------------------------------------------------------
 LLAMA_PIPELINES = {}
 MUSICGEN_MODELS = {}
 TTS_MODELS = {}
 
+# ---------------------------------------------------------------------
+# Helper Functions
+# ---------------------------------------------------------------------
 def get_llama_pipeline(model_id: str, token: str):
-    """Load and cache the LLaMA text-generation pipeline."""
+    """
+    Returns a cached LLaMA pipeline if available; otherwise, loads it.
+    """
     if model_id in LLAMA_PIPELINES:
         return LLAMA_PIPELINES[model_id]
 
@@ -47,434 +52,339 @@ def get_llama_pipeline(model_id: str, token: str):
     LLAMA_PIPELINES[model_id] = text_pipeline
     return text_pipeline
 
+
 def get_musicgen_model(model_key: str = "facebook/musicgen-large"):
-    """Load and cache the MusicGen model and processor."""
+    """
+    Returns a cached MusicGen model if available; otherwise, loads it.
+    Uses the 'large' variant for higher quality outputs.
+    """
     if model_key in MUSICGEN_MODELS:
         return MUSICGEN_MODELS[model_key]
 
     model = MusicgenForConditionalGeneration.from_pretrained(model_key)
     processor = AutoProcessor.from_pretrained(model_key)
+
     device = "cuda" if torch.cuda.is_available() else "cpu"
     model.to(device)
     MUSICGEN_MODELS[model_key] = (model, processor)
     return model, processor
 
+
 def get_tts_model(model_name: str = "tts_models/en/ljspeech/tacotron2-DDC"):
-    """Load and cache the TTS model."""
+    """
+    Returns a cached TTS model if available; otherwise, loads it.
+    """
     if model_name in TTS_MODELS:
         return TTS_MODELS[model_name]
+
     tts_model = TTS(model_name)
     TTS_MODELS[model_name] = tts_model
     return tts_model
 
-# -----------------------------------------------------------
-# Core Functionality
-# -----------------------------------------------------------
+
+# ---------------------------------------------------------------------
+# Script Generation Function
+# ---------------------------------------------------------------------
 @spaces.GPU(duration=100)
 def generate_script(user_prompt: str, model_id: str, token: str, duration: int):
     """
-    Generate a professional promo script including a voice-over script,
-    sound design suggestions, and music recommendations.
+    Generates a script, sound design suggestions, and music ideas from a user prompt.
+    Returns a tuple of strings: (voice_script, sound_design, music_suggestions).
     """
     try:
         text_pipeline = get_llama_pipeline(model_id, token)
-        # Updated prompt to instruct the model to output sections with explicit headers.
+
         system_prompt = (
-            f"You are a professional audio producer creating {duration}-second content. "
-            "Please generate the following three sections exactly as shown:\n\n"
-            "Voice-Over Script: [A clear and concise script for the voiceover.]\n"
-            "Sound Design Suggestions: [Specific ideas, effects, and ambience recommendations.]\n"
-            "Music Suggestions: [Recommendations for music style, genre, and tempo.]\n\n"
-            "Make sure each section starts with its header exactly."
+            "You are an expert radio imaging producer specializing in sound design and music. "
+            f"Based on the user's concept and the selected duration of {duration} seconds, produce the following: "
+            "1. A concise voice-over script. Prefix this section with 'Voice-Over Script:'.\n"
+            "2. Suggestions for sound design. Prefix this section with 'Sound Design Suggestions:'.\n"
+            "3. Music styles or track recommendations. Prefix this section with 'Music Suggestions:'."
         )
-        
-        full_prompt = f"{system_prompt}\nClient brief: {user_prompt}\nOutput:"
-        
+        combined_prompt = f"{system_prompt}\nUser concept: {user_prompt}\nOutput:"
+
         with torch.inference_mode():
             result = text_pipeline(
-                full_prompt,
-                max_new_tokens=400,
+                combined_prompt,
+                max_new_tokens=300,
                 do_sample=True,
-                temperature=0.7,
-                top_p=0.9
+                temperature=0.8
             )
 
-        generated_text = result[0]["generated_text"].split("Output:")[-1].strip()
-        
-        # Parse the output into the three expected sections.
-        sections = {
-            "Voice-Over Script:": "",
-            "Sound Design Suggestions:": "",
-            "Music Suggestions:": ""
-        }
-        
-        current_section = None
-        for line in generated_text.split('\n'):
-            for section in sections:
-                if section in line:
-                    current_section = section
-                    # Remove header from the line.
-                    line = line.replace(section, '').strip()
-                    break
-            if current_section:
-                sections[current_section] += line + '\n'
-        
-        return (
-            sections["Voice-Over Script:"].strip() or "No script generated",
-            sections["Sound Design Suggestions:"].strip() or "No sound design suggestions",
-            sections["Music Suggestions:"].strip() or "No music suggestions"
-        )
+        generated_text = result[0]["generated_text"]
+        if "Output:" in generated_text:
+            generated_text = generated_text.split("Output:")[-1].strip()
+
+        # Default placeholders
+        voice_script = "No voice-over script found."
+        sound_design = "No sound design suggestions found."
+        music_suggestions = "No music suggestions found."
+
+        # Voice-Over Script
+        if "Voice-Over Script:" in generated_text:
+            parts = generated_text.split("Voice-Over Script:")
+            voice_script_part = parts[1]
+            if "Sound Design Suggestions:" in voice_script_part:
+                voice_script = voice_script_part.split("Sound Design Suggestions:")[0].strip()
+            else:
+                voice_script = voice_script_part.strip()
+
+        # Sound Design
+        if "Sound Design Suggestions:" in generated_text:
+            parts = generated_text.split("Sound Design Suggestions:")
+            sound_design_part = parts[1]
+            if "Music Suggestions:" in sound_design_part:
+                sound_design = sound_design_part.split("Music Suggestions:")[0].strip()
+            else:
+                sound_design = sound_design_part.strip()
+
+        # Music Suggestions
+        if "Music Suggestions:" in generated_text:
+            parts = generated_text.split("Music Suggestions:")
+            music_suggestions = parts[1].strip()
+
+        return voice_script, sound_design, music_suggestions
 
     except Exception as e:
-        return f"Error: {str(e)}", "", ""
+        return f"Error generating script: {e}", "", ""
 
+
+# ---------------------------------------------------------------------
+# Voice-Over Generation Function
+# ---------------------------------------------------------------------
 @spaces.GPU(duration=100)
-def generate_voice(script: str, tts_model_name: str):
+def generate_voice(script: str, tts_model_name: str = "tts_models/en/ljspeech/tacotron2-DDC"):
     """
-    Generate full voice-over audio from the provided script using a TTS model.
+    Generates a voice-over from the provided script using the Coqui TTS model.
+    Returns the file path to the generated .wav file.
     """
     try:
         if not script.strip():
-            return None
+            return "Error: No script provided."
+
         tts_model = get_tts_model(tts_model_name)
-        # Create a unique temporary file name for the output.
-        output_path = os.path.join(tempfile.gettempdir(), f"voice_{uuid.uuid4().hex}.wav")
+
+        # Generate and save voice
+        output_path = os.path.join(tempfile.gettempdir(), "voice_over.wav")
         tts_model.tts_to_file(text=script, file_path=output_path)
         return output_path
-    except Exception as e:
-        print(f"Voice generation error: {e}")
-        return None
 
-@spaces.GPU(duration=100)
-def generate_voice_preview(script: str, tts_model_name: str):
-    """
-    Generate a short preview of the voice-over by taking the first 100 words.
-    """
-    try:
-        if not script.strip():
-            return None
-        words = script.split()
-        preview_text = ' '.join(words[:100]) if len(words) > 100 else script
-        return generate_voice(preview_text, tts_model_name)
     except Exception as e:
-        print(f"Voice preview error: {e}")
-        return None
+        return f"Error generating voice: {e}"
 
+
+# ---------------------------------------------------------------------
+# Music Generation Function
+# ---------------------------------------------------------------------
 @spaces.GPU(duration=100)
 def generate_music(prompt: str, audio_length: int):
     """
-    Generate music audio from a text prompt using the MusicGen model.
+    Generates music from the 'facebook/musicgen-large' model based on the prompt.
+    Returns the file path to the generated .wav file.
     """
     try:
-        model, processor = get_musicgen_model()
+        if not prompt.strip():
+            return "Error: No music suggestion provided."
+
+        model_key = "facebook/musicgen-large"
+        musicgen_model, musicgen_processor = get_musicgen_model(model_key)
+
         device = "cuda" if torch.cuda.is_available() else "cpu"
-        inputs = processor(text=[prompt], padding=True, return_tensors="pt").to(device)
-        
+        inputs = musicgen_processor(text=[prompt], padding=True, return_tensors="pt").to(device)
+
         with torch.inference_mode():
-            outputs = model.generate(**inputs, max_new_tokens=audio_length)
-        
-        # Assuming outputs[0, 0] holds the generated audio waveform.
+            outputs = musicgen_model.generate(**inputs, max_new_tokens=audio_length)
+
         audio_data = outputs[0, 0].cpu().numpy()
-        # Prevent division by zero during normalization.
-        max_val = np.max(np.abs(audio_data))
-        if max_val == 0:
-            normalized_audio = audio_data.astype("int16")
-        else:
-            normalized_audio = (audio_data / max_val * 32767).astype("int16")
-        output_path = os.path.join(tempfile.gettempdir(), f"music_{uuid.uuid4().hex}.wav")
+        normalized_audio = (audio_data / max(abs(audio_data)) * 32767).astype("int16")
+
+        output_path = f"{tempfile.gettempdir()}/musicgen_large_generated_music.wav"
         write(output_path, 44100, normalized_audio)
+
         return output_path
+
     except Exception as e:
-        print(f"Music generation error: {e}")
-        return None
+        return f"Error generating music: {e}"
+
 
+# ---------------------------------------------------------------------
+# Audio Blending with Duration Sync & Ducking
+# ---------------------------------------------------------------------
 @spaces.GPU(duration=100)
-def blend_audio(voice_path: str, music_path: str, ducking: bool, duck_level: int):
+def blend_audio(voice_path: str, music_path: str, ducking: bool, duck_level: int = 10):
     """
-    Blend the generated voice and music audio files.
-    If ducking is enabled, lower the music volume during the voice segments.
+    Blends two audio files (voice and music).
+    1. If music < voice, loops the music until it meets/exceeds the voice duration.
+    2. If music > voice, trims music to the voice duration.
+    3. If ducking=True, the music is attenuated by 'duck_level' dB while the voice is playing.
+    Returns the file path to the blended .wav file.
     """
     try:
+        if not os.path.isfile(voice_path) or not os.path.isfile(music_path):
+            return "Error: Missing audio files for blending."
+
         voice = AudioSegment.from_wav(voice_path)
         music = AudioSegment.from_wav(music_path)
-        
-        # Loop the music track if it's shorter than the voice track.
-        if len(music) < len(voice):
-            loops_needed = (len(voice) // len(music)) + 1
-            music = music * loops_needed
-        music = music[:len(voice)]
-        
+
+        voice_len = len(voice)  # in milliseconds
+        music_len = len(music)  # in milliseconds
+
+        # 1) If the music is shorter than the voice, loop it:
+        if music_len < voice_len:
+            looped_music = AudioSegment.empty()
+            # Keep appending until we exceed voice length
+            while len(looped_music) < voice_len:
+                looped_music += music
+            music = looped_music
+
+        # 2) If the music is longer than the voice, truncate it:
+        if len(music) > voice_len:
+            music = music[:voice_len]
+
+        # Now music and voice are the same length
         if ducking:
+            # Step 1: Reduce music dB while voice is playing
             ducked_music = music - duck_level
+            # Step 2: Overlay voice on top of ducked music
             final_audio = ducked_music.overlay(voice)
         else:
+            # No ducking, just overlay
             final_audio = music.overlay(voice)
-        
-        output_path = os.path.join(tempfile.gettempdir(), f"final_mix_{uuid.uuid4().hex}.wav")
+
+        output_path = os.path.join(tempfile.gettempdir(), "blended_output.wav")
         final_audio.export(output_path, format="wav")
         return output_path
+
     except Exception as e:
-        print(f"Mixing error: {e}")
-        return None
-
-# -----------------------------------------------------------
-# Enhanced UI Components
-# -----------------------------------------------------------
-custom_css = """
-#main-container {
-    max-width: 1200px;
-    margin: 0 auto;
-    padding: 20px;
-    background: #f0f9fb;
-    border-radius: 15px;
-    box-shadow: 0 4px 6px rgba(0,0,0,0.05);
-}
-
-.header {
-    text-align: center;
-    padding: 2em;
-    background: linear-gradient(135deg, #2a9d8f 0%, #457b9d 100%);
-    color: white;
-    border-radius: 15px;
-    margin-bottom: 2em;
-    border: 1px solid #264653;
-}
-
-.tab-nav {
-    background: none !important;
-    border: none !important;
-}
-
-.tab-button {
-    padding: 1em 2em !important;
-    border-radius: 8px !important;
-    margin: 0 5px !important;
-    transition: all 0.3s ease !important;
-    background: #e9f5f4 !important;
-    border: 1px solid #a8dadc !important;
-    color: #1d3557 !important;
-}
-
-.tab-button:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 3px 6px rgba(42,157,143,0.2);
-    background: #caf0f8 !important;
-}
-
-.dark-btn {
-    background: linear-gradient(135deg, #457b9d 0%, #2a9d8f 100%) !important;
-    color: white !important;
-    border: none !important;
-    padding: 12px 24px !important;
-    border-radius: 8px !important;
-    transition: transform 0.2s ease !important;
-}
-
-.dark-btn:hover {
-    transform: scale(1.02);
-    box-shadow: 0 3px 8px rgba(42,157,143,0.3);
-}
-
-.output-card {
-    background: #f8fbfe !important;
-    border-radius: 10px !important;
-    padding: 20px !important;
-    box-shadow: 0 2px 4px rgba(69,123,157,0.1) !important;
-    border: 1px solid #e2e8f0;
-}
-
-.progress-indicator {
-    color: #457b9d;
-    font-style: italic;
-    margin-top: 10px;
-}
-
-/* Additional Color Elements */
-h1, h2, h3 {
-    color: #1d3557 !important;
-}
-
-audio {
-    border: 1px solid #a8dadc !important;
-    border-radius: 8px !important;
-}
-
-.slider-handle {
-    background: #2a9d8f !important;
-}
-"""
-
-with gr.Blocks(css=custom_css, theme=gr.themes.Default()) as demo:
-    with gr.Column(elem_id="main-container"):
-        # Header Section
-        with gr.Column(elem_classes="header"):
-            gr.Markdown("""
-            # 🎙️ AI Promo Studio
-            **Professional Audio Production Suite Powered by AI**
-            """)
-        
-        # Main Workflow Tabs
-        with gr.Tabs(elem_classes="tab-nav"):
-            # Script Generation Tab
-            with gr.Tab("📝 Script Design", elem_classes="tab-button"):
-                with gr.Row(equal_height=False):
-                    with gr.Column(scale=2):
-                        gr.Markdown("### 🎯 Project Brief")
-                        user_prompt = gr.Textbox(
-                            label="Describe your promo concept",
-                            placeholder="e.g., 'An intense 30-second movie trailer intro with epic orchestral music and dramatic sound effects...'",
-                            lines=4
-                        )
-                        with gr.Row():
-                            duration = gr.Slider(
-                                label="Duration (seconds)",
-                                minimum=15,
-                                maximum=120,
-                                step=15,
-                                value=30,
-                                interactive=True
-                            )
-                            llama_model_id = gr.Dropdown(
-                                label="AI Model",
-                                choices=["meta-llama/Meta-Llama-3-8B-Instruct"],
-                                value="meta-llama/Meta-Llama-3-8B-Instruct",
-                                interactive=True
-                            )
-                        generate_btn = gr.Button("Generate Script 🚀", elem_classes="dark-btn")
-                    
-                    with gr.Column(scale=1, elem_classes="output-card"):
-                        gr.Markdown("### 📄 Generated Content")
-                        script_output = gr.Textbox(label="Voice Script", lines=6)
-                        sound_design_output = gr.Textbox(label="Sound Design", lines=3)
-                        music_suggestion_output = gr.Textbox(label="Music Style", lines=3)
-
-            # Voice Production Tab
-            with gr.Tab("🎙️ Voice Production", elem_classes="tab-button"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 🔊 Voice Settings")
-                        tts_model = gr.Dropdown(
-                            label="Voice Model",
-                            choices=[
-                                "tts_models/en/ljspeech/tacotron2-DDC",
-                                "tts_models/en/ljspeech/vits",
-                                "tts_models/en/sam/tacotron-DDC"
-                            ],
-                            value="tts_models/en/ljspeech/tacotron2-DDC",
-                            interactive=True
-                        )
-                        with gr.Row():
-                            voice_preview_btn = gr.Button("Preview Sample", elem_classes="dark-btn")
-                            voice_generate_btn = gr.Button("Generate Full Voiceover", elem_classes="dark-btn")
-                    with gr.Column(scale=1, elem_classes="output-card"):
-                        gr.Markdown("### 🎧 Voice Preview")
-                        voice_audio = gr.Audio(
-                            label="Generated Voice",
-                            interactive=False,
-                            waveform_options={"show_controls": True}
-                        )
-
-            # Music Production Tab
-            with gr.Tab("🎵 Music Design", elem_classes="tab-button"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 🎹 Music Parameters")
-                        audio_length = gr.Slider(
-                            label="Generation Length",
-                            minimum=256,
-                            maximum=1024,
-                            step=64,
-                            value=512,
-                            info="Higher values = longer generation time"
-                        )
-                        music_generate_btn = gr.Button("Generate Music Track", elem_classes="dark-btn")
-                    with gr.Column(scale=1, elem_classes="output-card"):
-                        gr.Markdown("### 🎶 Music Preview")
-                        music_output = gr.Audio(
-                            label="Generated Music",
-                            interactive=False,
-                            waveform_options={"show_controls": True}
-                        )
-
-            # Final Mix Tab
-            with gr.Tab("🔊 Final Mix", elem_classes="tab-button"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 🎚️ Mixing Console")
-                        ducking_enabled = gr.Checkbox(
-                            label="Enable Voice Ducking",
-                            value=True,
-                            info="Automatically lower music during voice segments"
-                        )
-                        duck_level = gr.Slider(
-                            label="Ducking Intensity (dB)",
-                            minimum=3,
-                            maximum=20,
-                            step=1,
-                            value=10
-                        )
-                        mix_btn = gr.Button("Generate Final Mix", elem_classes="dark-btn")
-                    with gr.Column(scale=1, elem_classes="output-card"):
-                        gr.Markdown("### 🎧 Final Production")
-                        final_mix = gr.Audio(
-                            label="Mixed Output",
-                            interactive=False,
-                            waveform_options={"show_controls": True}
-                        )
-
-        # Footer Section
-        with gr.Column(elem_classes="output-card"):
-            gr.Markdown("""
-            <div style="text-align: center; padding: 1.5em 0;">
-                <a href="https://bilsimaging.com" target="_blank">
-                    <img src="https://bilsimaging.com/logo.png" alt="Bils Imaging" style="height: 35px; margin-right: 15px;">
-                </a>
-                <a href="https://visitorbadge.io/status?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold">
-                    <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold&countColor=%23263759" />
-                </a>
-            </div>
-            <p style="text-align: center; color: #666; font-size: 0.9em;">
-                Professional Audio Production Suite v2.1 © 2024 | Bils Imaging
-            </p>
-            """)
-
-    # -----------------------------------------------------------
-    # Event Handling
-    # -----------------------------------------------------------
-    # Hidden textbox for HF_TOKEN (its value is set via the environment variable).
-    hf_token_hidden = gr.Textbox(value=HF_TOKEN, visible=False)
-    
-    generate_btn.click(
-        generate_script,
-        inputs=[user_prompt, llama_model_id, hf_token_hidden, duration],
-        outputs=[script_output, sound_design_output, music_suggestion_output]
-    )
-    
-    # Voice preview: generates a trimmed version of the script.
-    voice_preview_btn.click(
-        generate_voice_preview,
-        inputs=[script_output, tts_model],
-        outputs=voice_audio
-    )
-    
-    # Full voice generation using the complete script.
-    voice_generate_btn.click(
-        generate_voice,
-        inputs=[script_output, tts_model],
-        outputs=voice_audio
-    )
-    
-    music_generate_btn.click(
-        generate_music,
-        inputs=[music_suggestion_output, audio_length],
-        outputs=music_output
-    )
-    
-    mix_btn.click(
-        blend_audio,
-        inputs=[voice_audio, music_output, ducking_enabled, duck_level],
-        outputs=final_mix
-    )
+        return f"Error blending audio: {e}"
+
+
+# ---------------------------------------------------------------------
+# Gradio Interface
+# ---------------------------------------------------------------------
+with gr.Blocks() as demo:
+    gr.Markdown("""
+# 🎧 AI Promo Studio
+Welcome to **AI Promo Studio**, your all-in-one solution for creating professional, engaging audio promos with minimal effort!  
+
+This next-generation platform uses powerful AI models to handle:
+- **Script Generation**: Craft concise and impactful copy with LLaMA.
+- **Voice Synthesis**: Convert text into natural-sounding voice-overs using Coqui TTS.
+- **Music Production**: Generate custom music tracks with MusicGen Large for sound bed.
+- **Seamless Blending**: Easily combine voice and music—loop or trim tracks to match your desired promo length, with optional ducking to keep the voice front and center.
+
+Whether you’re a radio producer, podcaster, or content creator, **AI Promo Studio** streamlines your entire production pipeline—cutting hours of manual editing down to a few clicks.
+""")
+
+
+    with gr.Tabs():
+        # Step 1: Generate Script
+        with gr.Tab("Step 1: Generate Script"):
+            with gr.Row():
+                user_prompt = gr.Textbox(
+                    label="Promo Idea", 
+                    placeholder="E.g., A 30-second promo for a morning show...",
+                    lines=2
+                )
+                llama_model_id = gr.Textbox(
+                    label="LLaMA Model ID", 
+                    value="meta-llama/Meta-Llama-3-8B-Instruct", 
+                    placeholder="Enter a valid Hugging Face model ID"
+                )
+                duration = gr.Slider(
+                    label="Desired Promo Duration (seconds)",
+                    minimum=15, 
+                    maximum=60, 
+                    step=15, 
+                    value=30
+                )
+
+            generate_script_button = gr.Button("Generate Script")
+            script_output = gr.Textbox(label="Generated Voice-Over Script", lines=5, interactive=False)
+            sound_design_output = gr.Textbox(label="Sound Design Suggestions", lines=3, interactive=False)
+            music_suggestion_output = gr.Textbox(label="Music Suggestions", lines=3, interactive=False)
+
+            generate_script_button.click(
+                fn=lambda user_prompt, model_id, dur: generate_script(user_prompt, model_id, HF_TOKEN, dur),
+                inputs=[user_prompt, llama_model_id, duration],
+                outputs=[script_output, sound_design_output, music_suggestion_output],
+            )
+
+        # Step 2: Generate Voice
+        with gr.Tab("Step 2: Generate Voice"):
+            gr.Markdown("Generate the voice-over using a Coqui TTS model.")
+            selected_tts_model = gr.Dropdown(
+                label="TTS Model",
+                choices=[
+                    "tts_models/en/ljspeech/tacotron2-DDC",  
+                    "tts_models/en/ljspeech/vits", 
+                    "tts_models/en/sam/tacotron-DDC", 
+                ],
+                value="tts_models/en/ljspeech/tacotron2-DDC",
+                multiselect=False
+            )
+            generate_voice_button = gr.Button("Generate Voice-Over")
+            voice_audio_output = gr.Audio(label="Voice-Over (WAV)", type="filepath")
+
+            generate_voice_button.click(
+                fn=lambda script, tts_model: generate_voice(script, tts_model),
+                inputs=[script_output, selected_tts_model],
+                outputs=voice_audio_output,
+            )
+
+        # Step 3: Generate Music (MusicGen Large)
+        with gr.Tab("Step 3: Generate Music"):
+            gr.Markdown("Generate a music track with the **MusicGen Large** model.")
+            audio_length = gr.Slider(
+                label="Music Length (tokens)",
+                minimum=128, 
+                maximum=1024, 
+                step=64, 
+                value=512,
+                info="Increase tokens for longer audio, but be mindful of inference time."
+            )
+            generate_music_button = gr.Button("Generate Music")
+            music_output = gr.Audio(label="Generated Music (WAV)", type="filepath")
+
+            generate_music_button.click(
+                fn=lambda music_suggestion, length: generate_music(music_suggestion, length),
+                inputs=[music_suggestion_output, audio_length],
+                outputs=[music_output],
+            )
+
+        # Step 4: Blend Audio (Loop/Trim + Ducking)
+        with gr.Tab("Step 4: Blend Audio"):
+            gr.Markdown("**Music** will be looped or trimmed to match **Voice** duration, then optionally ducked.")
+            ducking_checkbox = gr.Checkbox(label="Enable Ducking?", value=True)
+            duck_level_slider = gr.Slider(
+                label="Ducking Level (dB attenuation)", 
+                minimum=0, 
+                maximum=20, 
+                step=1, 
+                value=10
+            )
+            blend_button = gr.Button("Blend Voice + Music")
+            blended_output = gr.Audio(label="Final Blended Output (WAV)", type="filepath")
+
+            blend_button.click(
+                fn=blend_audio,
+                inputs=[voice_audio_output, music_output, ducking_checkbox, duck_level_slider],
+                outputs=blended_output
+            )
 
-if __name__ == "__main__":
-    demo.launch(debug=True)
+    # Footer
+    gr.Markdown("""
+    <hr>
+    <p style="text-align: center; font-size: 0.9em;">
+        Created with ❤️ by <a href="https://bilsimaging.com" target="_blank">bilsimaging.com</a>
+    </p>
+    """)
+    
+    # Visitor Badge
+    gr.HTML("""
+    <a href="https://visitorbadge.io/status?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold">
+        <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold&countColor=%23263759" />
+    </a>
+    """)
+
+demo.launch(debug=True)