Refactor code structure for improved readability and maintainability

app.py

@@ -28,6 +28,7 @@ except ImportError:
 from loguru import logger
 
 from engine import TTSEngine
+from engine.audio_processor import AudioProcessor
 from engine.backends.chatterbox_backend import DEFAULT_VOICE_PROMPTS
 
 # --- Configuration ---
@@ -150,21 +151,46 @@ def get_default_voice(language: str) -> str:
     return DEFAULT_VOICE_PROMPTS.get(language)
 
 
+def get_background_music_choices() -> list[tuple[str, str]]:
+    """Get available background music choices."""
+    processor = AudioProcessor()
+    music_files = processor.list_available_music()
+
+    # Create choices with display names
+    choices = [("🔇 Keine Hintergrundmusik", "")]
+    for name in music_files:
+        # Create a nicer display name
+        display = name.replace("_", " ").replace("-", " ").title()
+        choices.append((f"🎵 {display}", name))
+
+    return choices
+
+
 # --- Main Generation Function ---
 @spaces.GPU
 def generate_announcement(
     text: str,
     language: str,
     voice_audio: str = None,
+    background_music: str = "",
+    custom_music: str = None,
+    music_volume: float = -15.0,
+    fade_in: float = 0.5,
+    fade_out: float = 0.5,
     seed: int = 0,
 ) -> tuple[int, np.ndarray]:
     """
     Generate a phone announcement.
 
     Args:
-        text: Text to synthesize (max 500 characters)
+        text: Text to synthesize (supports long text with automatic sentence splitting)
         language: Language code
         voice_audio: Optional path to reference audio for voice cloning
+        background_music: Name of preset background music file
+        custom_music: Path to custom uploaded background music
+        music_volume: Volume of background music in dB (default: -15)
+        fade_in: Fade in duration in seconds
+        fade_out: Fade out duration in seconds
         seed: Random seed (0 = random)
 
     Returns:
@@ -180,23 +206,77 @@ def generate_announcement(
         if DEVICE == "cuda":
             torch.cuda.manual_seed_all(seed)
 
-    # Truncate text
-    text = text[:500]
-
     # Use default voice if none provided
     if not voice_audio or not str(voice_audio).strip():
         voice_audio = get_default_voice(language)
 
-    logger.info(f"Generating: lang={language}, text='{text[:50]}...'")
-
-    # Generate audio
-    result = engine.generate(
-        text=text,
-        language=language,
-        voice_audio=voice_audio,
+    # Determine which background music to use (custom upload takes priority)
+    music_path = None
+    if custom_music and str(custom_music).strip():
+        music_path = custom_music
+        logger.info(f"Using custom background music: {music_path}")
+    elif background_music and str(background_music).strip():
+        music_path = background_music
+        logger.info(f"Using preset background music: {music_path}")
+
+    logger.info(
+        f"Generating: lang={language}, text='{text[:50]}...' ({len(text)} chars)"
     )
 
-    return result
+    # Generate audio (engine handles sentence splitting automatically)
+    # If we have background music, we need to process the audio
+    if music_path:
+        # Generate raw audio first (with sentence splitting for long texts)
+        result = engine.generate_raw(
+            text=text,
+            language=language,
+            voice_audio=voice_audio,
+            split_sentences=True,
+        )
+
+        # Process with background music
+        from engine.audio_processor import AudioProcessingConfig, AudioProcessor
+
+        processor = AudioProcessor(
+            AudioProcessingConfig(
+                background_music_path=music_path,
+                music_volume_db=music_volume,
+                fade_in_ms=int(fade_in * 1000),
+                fade_out_ms=int(fade_out * 1000),
+                padding_start_ms=int(
+                    fade_in * 1000 * 1.2
+                ),  # Slightly longer padding for fades
+                padding_end_ms=int(fade_out * 1000 * 1.2),
+            )
+        )
+
+        # Process and get bytes
+        processed_bytes = processor.process(
+            audio=result.audio,
+            sample_rate=result.sample_rate,
+        )
+
+        # Convert back to numpy for Gradio
+        import io
+
+        from pydub import AudioSegment
+
+        audio_segment = AudioSegment.from_mp3(io.BytesIO(processed_bytes))
+        samples = np.array(audio_segment.get_array_of_samples())
+
+        # Convert to float32 normalized
+        samples = samples.astype(np.float32) / 32768.0
+
+        return (audio_segment.frame_rate, samples)
+    else:
+        # No background music, use direct generation
+        result = engine.generate(
+            text=text,
+            language=language,
+            voice_audio=voice_audio,
+            split_sentences=True,
+        )
+        return result
 
 
 def on_language_change(language: str):
@@ -243,8 +323,8 @@ def create_interface():
                     label="📝 Text der Ansage",
                     placeholder="Geben Sie hier den Text Ihrer Telefonansage ein...",
                     lines=5,
-                    max_lines=10,
-                    info="Maximal 500 Zeichen",
+                    max_lines=15,
+                    info="Lange Texte werden automatisch in Sätze aufgeteilt",
                 )
 
                 with gr.Accordion("🎤 Stimmeinstellungen (Optional)", open=False):
@@ -261,6 +341,55 @@ def create_interface():
                         """
                     )
 
+                with gr.Accordion("🎵 Hintergrundmusik (Optional)", open=False):
+                    background_music = gr.Dropdown(
+                        choices=get_background_music_choices(),
+                        value="",
+                        label="Voreingestellte Musik",
+                        info="Wählen Sie eine Hintergrundmusik aus der Bibliothek",
+                    )
+
+                    custom_music = gr.Audio(
+                        sources=["upload"],
+                        type="filepath",
+                        label="Oder eigene Musik hochladen",
+                        elem_id="custom_music",
+                    )
+
+                    music_volume = gr.Slider(
+                        minimum=-30,
+                        maximum=0,
+                        value=-15,
+                        step=1,
+                        label="🔊 Musiklautstärke (dB)",
+                        info="Lautstärke der Hintergrundmusik relativ zur Sprache",
+                    )
+
+                    with gr.Row():
+                        fade_in = gr.Slider(
+                            minimum=0,
+                            maximum=3,
+                            value=0.5,
+                            step=0.1,
+                            label="⏫ Einblenden (Sek.)",
+                            info="Fade-In Dauer",
+                        )
+                        fade_out = gr.Slider(
+                            minimum=0,
+                            maximum=3,
+                            value=0.5,
+                            step=0.1,
+                            label="⏬ Ausblenden (Sek.)",
+                            info="Fade-Out Dauer",
+                        )
+
+                    gr.Markdown(
+                        """
+                        💡 **Hinweis:** Eigene hochgeladene Musik hat Vorrang vor der Auswahl.
+                        Die Musik wird automatisch geloopt und auf die Länge der Ansage zugeschnitten.
+                        """
+                    )
+
                 with gr.Accordion("⚙️ Erweiterte Einstellungen", open=False):
                     seed = gr.Number(
                         value=0,
@@ -286,8 +415,9 @@ def create_interface():
                     ### ℹ️ Hinweise
                     
                     - Die Generierung kann einige Sekunden dauern
-                    - Für beste Ergebnisse verwenden Sie klare, kurze Sätze
+                    - Lange Texte werden automatisch in Sätze aufgeteilt
                     - Referenz-Audio sollte 5-15 Sekunden lang sein
+                    - Hintergrundmusik wird automatisch geloopt
                     
                     ---
                     
@@ -309,7 +439,17 @@ def create_interface():
 
         generate_btn.click(
             fn=generate_announcement,
-            inputs=[text, language, voice_audio, seed],
+            inputs=[
+                text,
+                language,
+                voice_audio,
+                background_music,
+                custom_music,
+                music_volume,
+                fade_in,
+                fade_out,
+                seed,
+            ],
             outputs=[audio_output],
         )
 

engine/backends/base.py

@@ -3,6 +3,7 @@ Abstract base class for TTS backends.
 All TTS backends must implement this interface to be compatible with the engine.
 """
 
+import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Optional
@@ -10,6 +11,63 @@ from typing import Optional
 import numpy as np
 
 
+def split_into_sentences(text: str, max_chars: int = 250) -> list[str]:
+    """
+    Split text into sentences for better TTS quality on long texts.
+
+    Args:
+        text: Input text to split
+        max_chars: Maximum characters per chunk (default: 250)
+
+    Returns:
+        List of text chunks, each suitable for TTS generation
+    """
+    if len(text) <= max_chars:
+        return [text]
+
+    # Sentence-ending punctuation patterns
+    # Handles: . ! ? and their equivalents in other languages
+    sentence_enders = r"(?<=[.!?。？！،؟])\s+"
+
+    # Split by sentence endings
+    sentences = re.split(sentence_enders, text)
+
+    # Merge short sentences and split long ones
+    chunks = []
+    current_chunk = ""
+
+    for sentence in sentences:
+        sentence = sentence.strip()
+        if not sentence:
+            continue
+
+        # If sentence itself is too long, split by commas or other breaks
+        if len(sentence) > max_chars:
+            # Try splitting by comma, semicolon, or dash
+            sub_parts = re.split(r"(?<=[,;:،–—])\s+", sentence)
+            for part in sub_parts:
+                part = part.strip()
+                if not part:
+                    continue
+                if len(current_chunk) + len(part) + 1 <= max_chars:
+                    current_chunk = f"{current_chunk} {part}".strip()
+                else:
+                    if current_chunk:
+                        chunks.append(current_chunk)
+                    current_chunk = part
+        elif len(current_chunk) + len(sentence) + 1 <= max_chars:
+            current_chunk = f"{current_chunk} {sentence}".strip()
+        else:
+            if current_chunk:
+                chunks.append(current_chunk)
+            current_chunk = sentence
+
+    if current_chunk:
+        chunks.append(current_chunk)
+
+    return chunks if chunks else [text]
+
+
 @dataclass
 class TTSResult:
     """Result from TTS generation."""
@@ -124,6 +182,58 @@ class TTSBackend(ABC):
         """
         pass
 
+    def generate_long(
+        self,
+        text: str,
+        language: str = "de",
+        voice_audio_path: Optional[str] = None,
+        max_chars_per_chunk: int = 250,
+        silence_between_ms: int = 300,
+        **kwargs,
+    ) -> "TTSResult":
+        """
+        Generate speech from long text by splitting into sentences.
+
+        Args:
+            text: The text to synthesize (can be long)
+            language: Language code (e.g., "de", "en")
+            voice_audio_path: Optional path to reference audio for voice cloning
+            max_chars_per_chunk: Maximum characters per chunk (default: 250)
+            silence_between_ms: Silence between chunks in milliseconds (default: 300)
+            **kwargs: Backend-specific parameters
+
+        Returns:
+            TTSResult containing concatenated audio waveform and sample rate
+        """
+        from loguru import logger
+
+        chunks = split_into_sentences(text, max_chars_per_chunk)
+
+        if len(chunks) == 1:
+            return self.generate(text, language, voice_audio_path, **kwargs)
+
+        logger.info(f"Splitting text into {len(chunks)} chunks for generation")
+        audio_segments = []
+        sample_rate = None
+
+        for i, chunk in enumerate(chunks):
+            logger.debug(f"Generating chunk {i+1}/{len(chunks)}: '{chunk[:50]}...'")
+            result = self.generate(chunk, language, voice_audio_path, **kwargs)
+            audio_segments.append(result.audio)
+            if sample_rate is None:
+                sample_rate = result.sample_rate
+
+            # Add silence between chunks (except after last)
+            if i < len(chunks) - 1 and silence_between_ms > 0:
+                silence_samples = int(sample_rate * silence_between_ms / 1000)
+                silence = np.zeros(silence_samples, dtype=result.audio.dtype)
+                audio_segments.append(silence)
+
+        # Concatenate all segments
+        combined_audio = np.concatenate(audio_segments)
+
+        return TTSResult(audio=combined_audio, sample_rate=sample_rate)
+
     def __repr__(self) -> str:
         status = "loaded" if self._is_loaded else "not loaded"
         return f"{self.__class__.__name__}(name='{self.name}', status={status})"

engine/tts_engine.py

@@ -160,6 +160,8 @@ class TTSEngine:
         background_music: Optional[str] = None,
         output_path: Optional[str] = None,
         use_cache: bool = True,
+        split_sentences: bool = True,
+        max_chars_per_chunk: int = 250,
         **kwargs,
     ) -> Union[bytes, str, tuple[int, np.ndarray]]:
         """
@@ -172,6 +174,8 @@ class TTSEngine:
             background_music: Name/path of background music file
             output_path: Optional path to save output file
             use_cache: Whether to use caching (default: True)
+            split_sentences: Auto-split long text into sentences (default: True)
+            max_chars_per_chunk: Max chars per chunk when splitting (default: 250)
             **kwargs: Additional backend-specific parameters
 
         Returns:
@@ -203,11 +207,21 @@ class TTSEngine:
                     return output_path
                 return cached
 
-        # Generate audio
+        # Generate audio (use sentence splitting for long texts)
         logger.info(f"Generating TTS: backend={backend.name}, lang={language}")
-        result = backend.generate(
-            text=text, language=language, voice_audio_path=voice_audio, **kwargs
-        )
+        if split_sentences and len(text) > max_chars_per_chunk:
+            logger.info(f"Text is {len(text)} chars, splitting into sentences")
+            result = backend.generate_long(
+                text=text,
+                language=language,
+                voice_audio_path=voice_audio,
+                max_chars_per_chunk=max_chars_per_chunk,
+                **kwargs,
+            )
+        else:
+            result = backend.generate(
+                text=text, language=language, voice_audio_path=voice_audio, **kwargs
+            )
 
         # Determine if we need post-processing
         use_music = background_music or (
@@ -239,18 +253,40 @@ class TTSEngine:
         text: str,
         language: Optional[str] = None,
         voice_audio: Optional[str] = None,
+        split_sentences: bool = True,
+        max_chars_per_chunk: int = 250,
         **kwargs,
     ) -> TTSResult:
         """
         Generate raw audio without post-processing.
 
+        Args:
+            text: Text to synthesize
+            language: Language code (default from config)
+            voice_audio: Path/URL to reference audio for voice cloning
+            split_sentences: Auto-split long text into sentences (default: True)
+            max_chars_per_chunk: Max chars per chunk when splitting (default: 250)
+            **kwargs: Additional backend-specific parameters
+
         Returns:
             TTSResult with audio array and sample rate
         """
         language = language or self.config.default_language
-        return self.current_backend.generate(
-            text=text, language=language, voice_audio_path=voice_audio, **kwargs
-        )
+        backend = self.current_backend
+
+        if split_sentences and len(text) > max_chars_per_chunk:
+            logger.info(f"Text is {len(text)} chars, splitting into sentences")
+            return backend.generate_long(
+                text=text,
+                language=language,
+                voice_audio_path=voice_audio,
+                max_chars_per_chunk=max_chars_per_chunk,
+                **kwargs,
+            )
+        else:
+            return backend.generate(
+                text=text, language=language, voice_audio_path=voice_audio, **kwargs
+            )
 
     def list_background_music(self) -> list[str]:
         """List available background music files."""