Create interfaces/text_to_music.py

interfaces/text_to_music.py

@@ -0,0 +1,210 @@
+"""
+Text-to-Music generation interface
+"""
+import gradio as gr
+import numpy as np
+from typing import Optional
+import logging
+
+from models.model_manager import ModelManager
+from utils.ui_components import UIComponents
+from utils.audio_processor import AudioProcessor
+
+logger = logging.getLogger(__name__)
+
+class TextToMusicInterface:
+    def __init__(self, model_manager: ModelManager):
+        self.model_manager = model_manager
+        self.audio_processor = AudioProcessor()
+    
+    def create_interface(self) -> gr.Interface:
+        """Create the text-to-music interface"""
+        with gr.Group():
+            gr.Markdown("## 🎼 Text-to-Music Generation")
+            gr.Markdown("Generate music from text descriptions")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    text_input = gr.Textbox(
+                        label="Music Description",
+                        placeholder="Describe the music you want to generate...\nExamples:\n- Upbeat jazz with piano and drums\n- Electronic dance music with synthesizers\n- Calm acoustic guitar melody",
+                        lines=4,
+                        max_lines=6
+                    )
+                    
+                    with gr.Row():
+                        model_dropdown = UIComponents.create_model_dropdown()
+                        preset_dropdown = UIComponents.create_preset_dropdown()
+                    
+                    with gr.Row():
+                        duration_slider = UIComponents.create_duration_slider()
+                        guidance_slider = UIComponents.create_guidance_slider()
+                    
+                    with gr.Row():
+                        generate_btn = gr.Button("🎵 Generate Music", variant="primary", scale=2)
+                        cancel_btn = gr.Button("⏹️ Cancel", variant="secondary")
+                
+                with gr.Column(scale=3):
+                    audio_output = UIComponents.create_audio_player("Generated Music")
+                    
+                    with gr.Row():
+                        download_btn = gr.DownloadButton("💾 Download", variant="secondary")
+                        share_btn = gr.Button("🔗 Share", variant="secondary")
+                        regenerate_btn = gr.Button("🔄 Regenerate", variant="secondary")
+                    
+                    # Advanced options (collapsed by default)
+                    with gr.Accordion("Advanced Options", open=False):
+                        with gr.Row():
+                            temperature_slider = gr.Slider(0.1, 2.0, 1.0, label="Temperature")
+                            top_k_slider = gr.Slider(1, 100, 50, label="Top K")
+                        with gr.Row():
+                            seed_input = gr.Number(label="Seed (0 for random)", value=0, precision=0)
+                            batch_size = gr.Slider(1, 5, 1, step=1, label="Batch Size")
+            
+            # Visualization tabs
+            with gr.Tabs():
+                with gr.Tab("Waveform"):
+                    waveform_plot = gr.Plot(label="Waveform Visualization")
+                
+                with gr.Tab("Spectrogram"):
+                    spectrogram_plot = gr.Plot(label="Spectrogram")
+                
+                with gr.Tab("Audio Info"):
+                    info_text = gr.Textbox(label="Audio Information", lines=5, interactive=False)
+            
+            # Examples
+            gr.Examples(
+                examples=[
+                    ["Upbeat jazz with piano and drums, 120 BPM"],
+                    ["Electronic dance music with synthesizers, 128 BPM"],
+                    ["Calm acoustic guitar melody in the style of Bob Dylan"],
+                    ["Orchestral cinematic music, dramatic and emotional"],
+                    ["Lo-fi hip hop beat, relaxed and chill"],
+                    ["Classical piano piece in the style of Chopin"],
+                    ["Reggae with off-beat guitar and bass, 90 BPM"],
+                    ["Heavy metal with distorted guitars and fast drums"]
+                ],
+                inputs=text_input,
+                label="Example Prompts"
+            )
+        
+        # Event handlers
+        generate_btn.click(
+            fn=self.generate_music,
+            inputs=[
+                text_input, model_dropdown, duration_slider, guidance_slider,
+                temperature_slider, top_k_slider, seed_input
+            ],
+            outputs=[audio_output, waveform_plot, spectrogram_plot, info_text]
+        )
+        
+        preset_dropdown.change(
+            fn=self.apply_preset,
+            inputs=preset_dropdown,
+            outputs=[text_input, duration_slider, model_dropdown]
+        )
+        
+        regenerate_btn.click(
+            fn=self.regenerate_music,
+            inputs=[
+                text_input, model_dropdown, duration_slider, guidance_slider,
+                temperature_slider, top_k_slider
+            ],
+            outputs=[audio_output, waveform_plot, spectrogram_plot, info_text]
+        )
+        
+        return text_input
+    
+    def generate_music(
+        self,
+        prompt: str,
+        model_name: str,
+        duration: int,
+        guidance_scale: float,
+        temperature: float,
+        top_k: int,
+        seed: int
+    ):
+        """Generate music from text prompt"""
+        try:
+            if not prompt.strip():
+                raise gr.Error("Please enter a music description")
+            
+            # Get model
+            model = self.model_manager.get_model(model_name)
+            if not model:
+                raise gr.Error(f"Model {model_name} not available")
+            
+            # Set seed if provided
+            if seed > 0:
+                np.random.seed(seed)
+            
+            # Generate audio
+            logger.info(f"Generating music: {prompt[:50]}...")
+            
+            audio_array = model.generate_from_text(
+                prompt=prompt,
+                duration=duration,
+                guidance_scale=guidance_scale,
+                temperature=temperature,
+                top_k=top_k
+            )
+            
+            # Process audio
+            audio_array = self.audio_processor.normalize_audio(audio_array)
+            audio_array = self.audio_processor.apply_fade(audio_array)
+            
+            # Save to temporary file
+            output_path = self.audio_processor.create_temp_file()
+            self.audio_processor.save_audio(audio_array, output_path)
+            
+            # Create visualizations
+            waveform_fig = UIComponents.create_audio_visualization(audio_array)
+            spectrogram_fig = UIComponents.create_spectrogram_visualization(audio_array)
+            
+            # Audio info
+            info = self._get_audio_info(audio_array, duration)
+            
+            logger.info("Music generation completed successfully")
+            
+            return output_path, waveform_fig, spectrogram_fig, info
+            
+        except Exception as e:
+            logger.error(f"Generation failed: {str(e)}")
+            raise gr.Error(f"Generation failed: {str(e)}")
+    
+    def apply_preset(self, preset_name: str):
+        """Apply preset configuration"""
+        from config import PRESETS
+        if preset_name in PRESETS:
+            preset = PRESETS[preset_name]
+            return preset["prompt"], preset["duration"], preset["model"]
+        return "", 10, "musicgen_small"
+    
+    def regenerate_music(self, *args):
+        """Regenerate with same parameters but different seed"""
+        # Use random seed
+        args_list = list(args)
+        args_list[-1] = 0  # Set seed to 0 (random)
+        return self.generate_music(*args_list)
+    
+    def _get_audio_info(self, audio_array: np.ndarray, duration: int) -> str:
+        """Get audio information"""
+        from utils.audio_processor import AudioProcessor
+        processor = AudioProcessor()
+        
+        tempo = processor.get_tempo(audio_array)
+        sample_rate = processor.sample_rate
+        
+        info = f"""Generated Audio Information:
+        
+Duration: {duration} seconds
+Sample Rate: {sample_rate} Hz
+Channels: Mono
+Estimated Tempo: {tempo:.1f} BPM
+Total Samples: {len(audio_array)}
+File Size: ~{len(audio_array) * 2 / 1024 / 1024:.1f} MB
+Peak Amplitude: {np.max(np.abs(audio_array)):.3f}
+RMS Level: {np.sqrt(np.mean(audio_array**2)):.3f}"""
+        
+        return info