Update README and app structure for Gemini TTS integration; adjust backend defaults and voice selection logic

README.md

@@ -16,9 +16,9 @@ A modular text-to-speech engine for generating professional phone announcements
 
 ## Features
 
-- 🎙️ **High-Quality TTS**: Using Chatterbox Multilingual for natural speech synthesis
+- 🎙️ **Standard Voices (Default)**: Google Gemini TTS prebuilt voices
 - 🌍 **23 Languages**: German, English, French, Spanish, Italian, and many more
-- 🎭 **Voice Cloning**: Clone any voice from a short audio sample
+- 🎭 **Voice Cloning**: Uses Chatterbox Multilingual + reference audio
 - 🔌 **Modular Architecture**: Easy to swap TTS backends
 - 🎵 **Background Music**: Optional background music mixing
 - 💾 **Caching**: Local and HuggingFace Hub caching support
@@ -30,7 +30,7 @@ A modular text-to-speech engine for generating professional phone announcements
 pip install -r requirements.txt
 
 # Run the application
-python app_new.py
+python app.py
 ```
 
 ## Architecture
@@ -156,8 +156,8 @@ engine = TTSEngine(config)
 
 ### Environment Variables
 
-- `HF_TOKEN`: HuggingFace token for model downloads
-- `GEMINI_API_KEY`: Google API key (for Gemini backend)
+- `HF_TOKEN`: HuggingFace token for model downloads (Chatterbox)
+- `GEMINI_API_KEY`: Google API key (Gemini TTS; default for standard voices)
 
 ## Supported Languages
 

app.py

@@ -1,10 +1,13 @@
-"""
-Telefonansagen TTS - Simplified Gradio Application
+"""Telefonansagen TTS - Gradio Application.
 
-A streamlined interface for generating professional phone announcements
-using the modular TTS engine with Chatterbox Multilingual as default backend.
+UI requirements:
+- Use Gemini TTS by default for standard voices
+- Provide a dropdown to choose a voice
+- Include a "Voice cloning" option; when selected, show reference-audio upload
+    and use Chatterbox (voice cloning capable) backend.
 """
 
+import os
 import random
 
 import gradio as gr
@@ -31,6 +34,14 @@ from engine import TTSEngine
 from engine.audio_processor import AudioProcessor
 from engine.backends.chatterbox_backend import DEFAULT_VOICE_PROMPTS
 
+try:
+    from engine.backends.gemini_backend import GeminiBackend
+
+    HAS_GEMINI_BACKEND = True
+except Exception:
+    GeminiBackend = None
+    HAS_GEMINI_BACKEND = False
+
 # --- Configuration ---
 DEVICE = (
     "cuda"
@@ -98,6 +109,21 @@ EXAMPLE_TEXTS = {
 ENGINE = None
 
 
+VOICE_CLONING_OPTION = "Voice cloning"
+
+
+def _is_gemini_ready() -> bool:
+    """Return True if Gemini backend can likely be used."""
+    if not HAS_GEMINI_BACKEND:
+        return False
+    try:
+        import google.genai  # noqa: F401
+
+        return bool(os.environ.get("GEMINI_API_KEY"))
+    except Exception:
+        return False
+
+
 def get_engine() -> TTSEngine:
     """Get or initialize the TTS engine."""
     global ENGINE
@@ -108,13 +134,23 @@ def get_engine() -> TTSEngine:
         logger.info("Initializing TTS Engine...")
         ENGINE = TTSEngine(
             EngineConfig(
-                default_backend="chatterbox",
+                default_backend="gemini",
                 device=DEVICE,
                 default_language="de",
             )
         )
-        # Pre-load the model
-        ENGINE.load_backend()
+
+        # Pre-load preferred backend if possible; fall back to chatterbox.
+        try:
+            ENGINE.load_backend("gemini")
+            ENGINE.set_backend("gemini")
+        except Exception as e:
+            logger.warning(
+                f"Gemini backend not ready ({e}). Falling back to chatterbox."
+            )
+            ENGINE.set_backend("chatterbox")
+            ENGINE.load_backend("chatterbox")
+
         logger.info("TTS Engine ready!")
 
     return ENGINE
@@ -141,6 +177,17 @@ def get_language_choices() -> list[tuple[str, str]]:
     return choices
 
 
+def get_language_choices_for_backend(backend: str) -> list[tuple[str, str]]:
+    engine = get_engine()
+    supported = engine.get_supported_languages(backend=backend)
+    choices = []
+    for code in supported.keys():
+        display = LANGUAGE_DISPLAY.get(code, f"{supported[code]} ({code})")
+        choices.append((display, code))
+    choices.sort(key=lambda x: (x[1] != "de", x[0]))
+    return choices
+
+
 def get_example_text(language: str) -> str:
     """Get example text for a language."""
     return EXAMPLE_TEXTS.get(language, EXAMPLE_TEXTS["en"])
@@ -151,6 +198,27 @@ def get_default_voice(language: str) -> str:
     return DEFAULT_VOICE_PROMPTS.get(language)
 
 
+def get_voice_choices() -> list[str]:
+    """Get voice dropdown choices.
+
+    - Standard voices: Gemini prebuilt voices
+    - Special entry: Voice cloning (uses Chatterbox)
+    """
+    voices: list[str] = []
+    if HAS_GEMINI_BACKEND:
+        try:
+            voices.extend(list(GeminiBackend.AVAILABLE_VOICES))
+        except Exception:
+            pass
+    # Always include the special option
+    voices.append(VOICE_CLONING_OPTION)
+    return voices
+
+
+def _resolve_backend_for_voice_choice(voice_choice: str) -> str:
+    return "chatterbox" if voice_choice == VOICE_CLONING_OPTION else "gemini"
+
+
 def get_background_music_choices() -> list[tuple[str, str]]:
     """Get available background music choices."""
     processor = AudioProcessor()
@@ -174,6 +242,7 @@ def get_background_music_choices() -> list[tuple[str, str]]:
 def generate_announcement(
     text: str,
     language: str,
+    voice_choice: str,
     voice_audio: str = None,
     background_music: str = "",
     custom_music: str = None,
@@ -201,6 +270,10 @@ def generate_announcement(
     """
     engine = get_engine()
 
+    # Select backend based on voice choice
+    backend_name = _resolve_backend_for_voice_choice(voice_choice)
+    engine.set_backend(backend_name)
+
     # Set seed for reproducibility
     if seed != 0:
         torch.manual_seed(seed)
@@ -209,9 +282,17 @@ def generate_announcement(
         if DEVICE == "cuda":
             torch.cuda.manual_seed_all(seed)
 
-    # Use default voice if none provided
-    if not voice_audio or not str(voice_audio).strip():
-        voice_audio = get_default_voice(language)
+    # Voice resolution:
+    # - Voice cloning: use reference audio (or fallback per-language prompt)
+    # - Standard voice: use Gemini prebuilt voice
+    voice_kwargs = {}
+    if backend_name == "chatterbox":
+        if not voice_audio or not str(voice_audio).strip():
+            voice_audio = get_default_voice(language)
+    else:
+        voice_audio = None
+        if voice_choice and voice_choice != VOICE_CLONING_OPTION:
+            voice_kwargs["voice"] = voice_choice
 
     # Determine which background music to use (custom upload takes priority)
     music_path = None
@@ -235,6 +316,7 @@ def generate_announcement(
             language=language,
             voice_audio=voice_audio,
             split_sentences=True,
+            **voice_kwargs,
         )
 
         # Process with background music
@@ -278,13 +360,48 @@ def generate_announcement(
             language=language,
             voice_audio=voice_audio,
             split_sentences=True,
+            **voice_kwargs,
         )
         return result
 
 
-def on_language_change(language: str):
+def on_language_change(language: str, voice_choice: str):
     """Handle language selection change."""
-    return get_example_text(language), get_default_voice(language)
+    # Only update reference-audio default for voice cloning.
+    if voice_choice == VOICE_CLONING_OPTION:
+        return get_example_text(language), gr.update(value=None)
+    return get_example_text(language), gr.update()
+
+
+def on_voice_choice_change(voice_choice: str):
+    """Switch UI elements depending on voice selection."""
+    backend = _resolve_backend_for_voice_choice(voice_choice)
+
+    if backend == "gemini":
+        language_choices = get_language_choices_for_backend("gemini")
+        default_language = (
+            "de"
+            if any(v == "de" for _, v in language_choices)
+            else (language_choices[0][1] if language_choices else "en")
+        )
+        return (
+            gr.update(choices=language_choices, value=default_language),
+            gr.update(visible=False, value=None),
+            gr.update(value=get_example_text(default_language)),
+        )
+
+    # Voice cloning
+    language_choices = get_language_choices_for_backend("chatterbox")
+    default_language = (
+        "de"
+        if any(v == "de" for _, v in language_choices)
+        else (language_choices[0][1] if language_choices else "en")
+    )
+    return (
+        gr.update(choices=language_choices, value=default_language),
+        gr.update(visible=True, value=None),
+        gr.update(value=get_example_text(default_language)),
+    )
 
 
 # --- Gradio Interface ---
@@ -311,12 +428,45 @@ def create_interface():
             elem_classes=["main-title"],
         )
 
+        if not _is_gemini_ready():
+            gr.Markdown(
+                """
+                **Hinweis:** Gemini ist aktuell nicht verfügbar.
+                Bitte `google-genai` installieren und `GEMINI_API_KEY` setzen, oder **Voice cloning** verwenden.
+                """
+            )
+
         with gr.Row():
             # Left column - Input
             with gr.Column(scale=1):
+                default_voice_choice = (
+                    "Kore"
+                    if _is_gemini_ready() and "Kore" in get_voice_choices()
+                    else VOICE_CLONING_OPTION
+                )
+
+                voice_choice = gr.Dropdown(
+                    choices=get_voice_choices(),
+                    value=default_voice_choice,
+                    label="🗣️ Stimme / Voice",
+                    info="Standard: Gemini Stimmen. 'Voice cloning' nutzt Referenz-Audio (Chatterbox).",
+                )
+
                 language = gr.Dropdown(
-                    choices=get_language_choices(),
-                    value="de",
+                    choices=(
+                        get_language_choices_for_backend("gemini")
+                        if _is_gemini_ready()
+                        else get_language_choices_for_backend("chatterbox")
+                    ),
+                    value=(
+                        "de"
+                        if _is_gemini_ready()
+                        and any(
+                            v == "de"
+                            for _, v in get_language_choices_for_backend("gemini")
+                        )
+                        else "de"
+                    ),
                     label="🌍 Sprache / Language",
                     info="Wählen Sie die Sprache der Ansage",
                 )
@@ -335,7 +485,8 @@ def create_interface():
                         sources=["upload", "microphone"],
                         type="filepath",
                         label="Referenz-Audio für Stimmklonung",
-                        value=get_default_voice("de"),
+                        visible=(default_voice_choice == VOICE_CLONING_OPTION),
+                        value=None,
                     )
                     gr.Markdown(
                         """
@@ -433,9 +584,16 @@ def create_interface():
                 )
 
         # Event handlers
+        voice_choice.change(
+            fn=on_voice_choice_change,
+            inputs=[voice_choice],
+            outputs=[language, voice_audio, text],
+            show_progress=False,
+        )
+
         language.change(
             fn=on_language_change,
-            inputs=[language],
+            inputs=[language, voice_choice],
             outputs=[text, voice_audio],
             show_progress=False,
         )
@@ -445,6 +603,7 @@ def create_interface():
             inputs=[
                 text,
                 language,
+                voice_choice,
                 voice_audio,
                 background_music,
                 custom_music,

engine/tts_engine.py

@@ -28,7 +28,7 @@ class EngineConfig:
     """Configuration for the TTS Engine."""
 
     # Backend settings
-    default_backend: str = "chatterbox"
+    default_backend: str = "gemini"
     device: str = "auto"  # "auto", "cuda", "mps", "cpu"
 
     # Default generation settings
@@ -186,16 +186,20 @@ class TTSEngine:
         language = language or self.config.default_language
         backend = self.current_backend
 
-        # Generate voice ID for caching
-        voice_id = (
-            "default"
-            if not voice_audio
-            else (
+        # Generate voice ID for caching.
+        # - Voice cloning: derive from reference audio when available
+        # - Preset voices (e.g. Gemini): include requested voice in cache key
+        requested_voice = kwargs.get("voice")
+        if voice_audio:
+            voice_id = (
                 Path(voice_audio).stem
                 if os.path.exists(voice_audio or "")
                 else "custom"
             )
-        )
+        elif requested_voice:
+            voice_id = f"voice-{requested_voice}"
+        else:
+            voice_id = "default"
 
         # Check cache
         if use_cache and self._cache.config.enabled:

requirements.txt

@@ -26,7 +26,7 @@ huggingface_hub>=0.20.0
 loguru>=0.7.0
 
 # Optional: Gemini backend
-# google-genai>=0.3.0
+google-genai>=0.3.0
 
 # Optional: Caching to HuggingFace Hub
 # pandas>=2.0.0