1033 lines
35 KiB
Python
Executable file
1033 lines
35 KiB
Python
Executable file
#!/usr/bin/env python3
|
||
|
||
import argparse
|
||
import importlib.util
|
||
import queue
|
||
import re
|
||
import sys
|
||
import threading
|
||
import time
|
||
from pathlib import Path
|
||
from typing import List, Optional, Tuple
|
||
|
||
import torch
|
||
import torchaudio as ta
|
||
|
||
# SDPA does not support output_attentions=True (required by AlignmentStreamAnalyzer hook);
|
||
# fall back to eager attention so attention weights are returned as tensors, not None.
|
||
import chatterbox.models.t3.llama_configs as _llama_cfg
|
||
_llama_cfg.LLAMA_520M_CONFIG_DICT["attn_implementation"] = "eager"
|
||
|
||
from chatterbox.tts import ChatterboxTTS
|
||
|
||
try:
|
||
from chatterbox.mtl_tts import ChatterboxMultilingualTTS
|
||
HAS_MULTILINGUAL = True
|
||
except Exception:
|
||
ChatterboxMultilingualTTS = None
|
||
HAS_MULTILINGUAL = False
|
||
|
||
|
||
SUPPORTED_LANGS = {
|
||
"ar", "da", "de", "el", "en", "es", "fi", "fr", "he", "hi", "it",
|
||
"ja", "ko", "ms", "nl", "no", "pl", "pt", "ru", "sv", "sw", "tr", "zh"
|
||
}
|
||
|
||
SENTENCE_END_RE = re.compile(
|
||
r'.+?(?:'
|
||
r'\.\.\.|…|'
|
||
r'[!?¡¿]+|'
|
||
r'[！？。]+|'
|
||
r'‽|'
|
||
r'(?<!\d)\.' # Punkt, aber NICHT nach einer Ziffer (kein Ordinalzahl-Split)
|
||
r')(?=\s+|$)',
|
||
re.DOTALL
|
||
)
|
||
|
||
NON_SPELLED_ACRONYMS = {
|
||
"NATO",
|
||
"NASA",
|
||
"UNESCO",
|
||
"OPEC",
|
||
}
|
||
|
||
GERMAN_LETTER_NAMES = {
|
||
'A': 'Ah', 'B': 'Be', 'C': 'Tse', 'D': 'De', 'E': 'E',
|
||
'F': 'Ef', 'G': 'Ge', 'H': 'Ha', 'I': 'I', 'J': 'Jot',
|
||
'K': 'Ka', 'L': 'El', 'M': 'Em', 'N': 'En', 'O': 'O',
|
||
'P': 'Pe', 'Q': 'Ku', 'R': 'Er', 'S': 'Es', 'T': 'Te',
|
||
'U': 'U', 'V': 'Fau', 'W': 'We', 'X': 'Iks', 'Y': 'Ypsilon',
|
||
'Z': 'Tset',
|
||
}
|
||
|
||
# Trennlinien wie "--- Ende ---", "===", "---" filtern
|
||
# Matcht: reine Strichlinien ODER "---Wort---"-Muster mit kurzem Inhalt (<= 20 Zeichen)
|
||
SEPARATOR_LINE_RE = re.compile(r'^\s*-{2,}\s*[\w\s]{0,20}\s*-{2,}\s*$|^\s*[=_-]{3,}\s*$')
|
||
|
||
UPPER_ACRONYM_RE = re.compile(r'\b[A-ZÄÖÜ]{2,}(?:[A-ZÄÖÜ0-9]*[A-ZÄÖÜ])?\b')
|
||
# Akronym direkt vor Bindestrich + Wort: "US-Präsident", "NATO-Mitglied"
|
||
ACRONYM_COMPOUND_RE = re.compile(r'\b([A-ZÄÖÜ]{2,}(?:[A-ZÄÖÜ0-9]*[A-ZÄÖÜ])?)-(?=[A-ZÄÖÜa-zäöü])')
|
||
|
||
# Unterstützt:
|
||
# - 14:58
|
||
# - 14.58
|
||
# - 14:58 Uhr
|
||
# - 14.58 Uhr
|
||
TIME_RE = re.compile(r'\b([01]?\d|2[0-3])([:.])([0-5]\d)(?:\s*Uhr)?\b', re.IGNORECASE)
|
||
|
||
# Vierstellige Jahreszahlen
|
||
YEAR_RE = re.compile(r'\b(19\d{2}|20\d{2}|21\d{2})\b')
|
||
|
||
# Einfache deutsche Einheiten
|
||
UNIT_REPLACEMENTS = {
|
||
"km/h": "Kilometer pro Stunde",
|
||
"km": "Kilometer",
|
||
"m": "Meter",
|
||
"cm": "Zentimeter",
|
||
"mm": "Millimeter",
|
||
"kg": "Kilogramm",
|
||
"g": "Gramm",
|
||
"mg": "Milligramm",
|
||
"Hz": "Hertz",
|
||
"kHz": "Kilohertz",
|
||
"MHz": "Megahertz",
|
||
"GHz": "Gigahertz",
|
||
"€": "Euro",
|
||
"$": "Dollar",
|
||
"%": "Prozent",
|
||
"Kb": "Kilobyte",
|
||
"Mb": "Megabyte",
|
||
"GB": "Gigabyte",
|
||
"TB": "Terabyte",
|
||
"PB": "Petabyte",
|
||
}
|
||
|
||
# Eingebaute phonetische Annäherungen für häufige Fremdnamen (Deutsch)
|
||
DEFAULT_PRONUNCIATION_DE: dict[str, str] = {
|
||
"Xi Jinping": "Schi Jinping",
|
||
"Xi": "Schi",
|
||
"Jinping": "Jinping",
|
||
"Peking": "Peking", # bleibt — deutsches TTS kennt es
|
||
}
|
||
|
||
|
||
def apply_pronunciation_dict(text: str, pron_dict: dict[str, str]) -> str:
|
||
for phrase, replacement in sorted(pron_dict.items(), key=lambda x: len(x[0]), reverse=True):
|
||
text = text.replace(phrase, replacement)
|
||
return text
|
||
|
||
|
||
def clean_raw_text(text: str) -> str:
|
||
"""Unsichtbare Steuerzeichen entfernen, die Splitting oder TTS stoeren."""
|
||
for ch in ('', '', '', ''):
|
||
text = text.replace(ch, '')
|
||
return text
|
||
|
||
|
||
def has_module(name: str) -> bool:
|
||
return importlib.util.find_spec(name) is not None
|
||
|
||
|
||
def get_device(explicit_device: Optional[str] = None) -> str:
|
||
if explicit_device:
|
||
if explicit_device.startswith("cuda") and not torch.cuda.is_available():
|
||
raise RuntimeError("CUDA angefordert, aber keine CUDA-GPU verfügbar.")
|
||
if explicit_device.startswith("cuda"):
|
||
try:
|
||
idx = int(explicit_device.split(":")[1]) if ":" in explicit_device else 0
|
||
except (IndexError, ValueError):
|
||
idx = 0
|
||
torch.cuda.set_device(idx)
|
||
return explicit_device
|
||
|
||
if torch.cuda.is_available():
|
||
torch.cuda.set_device(0)
|
||
return "cuda:0"
|
||
|
||
return "cpu"
|
||
|
||
|
||
def number_to_words_de(n: int) -> str:
|
||
ones = {
|
||
0: "null", 1: "eins", 2: "zwei", 3: "drei", 4: "vier", 5: "fünf",
|
||
6: "sechs", 7: "sieben", 8: "acht", 9: "neun", 10: "zehn",
|
||
11: "elf", 12: "zwölf", 13: "dreizehn", 14: "vierzehn",
|
||
15: "fünfzehn", 16: "sechzehn", 17: "siebzehn", 18: "achtzehn",
|
||
19: "neunzehn"
|
||
}
|
||
tens = {
|
||
20: "zwanzig", 30: "dreißig", 40: "vierzig", 50: "fünfzig",
|
||
60: "sechzig", 70: "siebzig", 80: "achtzig", 90: "neunzig"
|
||
}
|
||
|
||
if n < 20:
|
||
return ones[n]
|
||
|
||
if n < 100:
|
||
t = (n // 10) * 10
|
||
o = n % 10
|
||
if o == 0:
|
||
return tens[t]
|
||
one_prefix = "ein" if o == 1 else ones[o]
|
||
return f"{one_prefix}und{tens[t]}"
|
||
|
||
if n < 1000:
|
||
h = n // 100
|
||
r = n % 100
|
||
prefix = "einhundert" if h == 1 else f"{ones[h]}hundert"
|
||
return prefix if r == 0 else f"{prefix}{number_to_words_de(r)}"
|
||
|
||
if n < 1000000:
|
||
th = n // 1000
|
||
r = n % 1000
|
||
prefix = "eintausend" if th == 1 else f"{number_to_words_de(th)}tausend"
|
||
return prefix if r == 0 else f"{prefix}{number_to_words_de(r)}"
|
||
|
||
return str(n)
|
||
|
||
|
||
def number_to_words_en(n: int) -> str:
|
||
ones = {
|
||
0: "zero", 1: "one", 2: "two", 3: "three", 4: "four", 5: "five",
|
||
6: "six", 7: "seven", 8: "eight", 9: "nine", 10: "ten",
|
||
11: "eleven", 12: "twelve", 13: "thirteen", 14: "fourteen",
|
||
15: "fifteen", 16: "sixteen", 17: "seventeen", 18: "eighteen",
|
||
19: "nineteen"
|
||
}
|
||
tens = {
|
||
20: "twenty", 30: "thirty", 40: "forty", 50: "fifty",
|
||
60: "sixty", 70: "seventy", 80: "eighty", 90: "ninety"
|
||
}
|
||
|
||
if n < 20:
|
||
return ones[n]
|
||
|
||
if n < 100:
|
||
t = (n // 10) * 10
|
||
o = n % 10
|
||
return tens[t] if o == 0 else f"{tens[t]}-{ones[o]}"
|
||
|
||
if n < 1000:
|
||
h = n // 100
|
||
r = n % 100
|
||
prefix = f"{ones[h]} hundred"
|
||
return prefix if r == 0 else f"{prefix} {number_to_words_en(r)}"
|
||
|
||
if n < 1000000:
|
||
th = n // 1000
|
||
r = n % 1000
|
||
prefix = f"{number_to_words_en(th)} thousand"
|
||
return prefix if r == 0 else f"{prefix} {number_to_words_en(r)}"
|
||
|
||
return str(n)
|
||
|
||
|
||
def year_to_words_de(year: int) -> str:
|
||
if year < 1000 or year > 9999:
|
||
return str(year)
|
||
|
||
if year == 2000:
|
||
return "zweitausend"
|
||
|
||
if 2001 <= year <= 2099:
|
||
return f"zweitausend{number_to_words_de(year - 2000)}"
|
||
|
||
return number_to_words_de(year)
|
||
|
||
|
||
def year_to_words_en(year: int) -> str:
|
||
if year < 1000 or year > 9999:
|
||
return str(year)
|
||
|
||
if 2000 <= year <= 2009:
|
||
if year == 2000:
|
||
return "two thousand"
|
||
return f"two thousand {number_to_words_en(year - 2000)}"
|
||
|
||
if 2010 <= year <= 2099:
|
||
last_two = year % 100
|
||
return f"twenty {number_to_words_en(last_two)}"
|
||
|
||
first_two = year // 100
|
||
last_two = year % 100
|
||
if last_two == 0:
|
||
return f"{number_to_words_en(first_two)} hundred"
|
||
return f"{number_to_words_en(first_two)} {number_to_words_en(last_two)}"
|
||
|
||
|
||
def spell_out_acronym(token: str, mode: str = "period_space") -> str:
|
||
chars = list(token)
|
||
|
||
if mode == "german":
|
||
return " ".join(GERMAN_LETTER_NAMES.get(c, c) for c in chars)
|
||
|
||
if mode == "space":
|
||
return " ".join(chars)
|
||
|
||
if mode == "period":
|
||
return ".".join(chars) + "."
|
||
|
||
if mode == "comma":
|
||
return ", ".join(chars)
|
||
|
||
if mode == "period_space":
|
||
return ". ".join(chars) + "."
|
||
|
||
raise ValueError(f"Unbekannter mode: {mode}")
|
||
|
||
|
||
def normalize_units(text: str, lang: str) -> str:
|
||
if lang != "de":
|
||
return text
|
||
|
||
for unit, expanded in sorted(UNIT_REPLACEMENTS.items(), key=lambda x: len(x[0]), reverse=True):
|
||
text = re.sub(rf'(?<=\d)\s*{re.escape(unit)}\b', f" {expanded}", text)
|
||
|
||
return text
|
||
|
||
|
||
def normalize_times(text: str, lang: str) -> str:
|
||
def repl(match: re.Match) -> str:
|
||
hh = int(match.group(1))
|
||
mm = int(match.group(3))
|
||
|
||
if lang == "de":
|
||
if mm == 0:
|
||
return f"{number_to_words_de(hh)} Uhr"
|
||
return f"{number_to_words_de(hh)} Uhr {number_to_words_de(mm)}"
|
||
|
||
if lang == "en":
|
||
if hh == 0 and mm == 0:
|
||
return "twelve midnight"
|
||
if hh == 12 and mm == 0:
|
||
return "twelve noon"
|
||
|
||
hour12 = hh % 12
|
||
if hour12 == 0:
|
||
hour12 = 12
|
||
suffix = "a m" if hh < 12 else "p m"
|
||
|
||
if mm == 0:
|
||
return f"{number_to_words_en(hour12)} {suffix}"
|
||
if mm < 10:
|
||
return f"{number_to_words_en(hour12)} oh {number_to_words_en(mm)} {suffix}"
|
||
return f"{number_to_words_en(hour12)} {number_to_words_en(mm)} {suffix}"
|
||
|
||
return match.group(0)
|
||
|
||
return TIME_RE.sub(repl, text)
|
||
|
||
|
||
def normalize_years(text: str, lang: str) -> str:
|
||
def repl(match: re.Match) -> str:
|
||
year = int(match.group(1))
|
||
|
||
if lang == "de":
|
||
return year_to_words_de(year)
|
||
|
||
if lang == "en":
|
||
return year_to_words_en(year)
|
||
|
||
return match.group(0)
|
||
|
||
return YEAR_RE.sub(repl, text)
|
||
|
||
|
||
def preprocess_tts_text(
|
||
text: str,
|
||
lang: str,
|
||
spell_uppercase_acronyms: bool = True,
|
||
acronym_mode: Optional[str] = None, # None = auto: 'german' bei de, sonst 'period_space'
|
||
normalize_time_values: bool = True,
|
||
normalize_year_values: bool = True,
|
||
normalize_units_values: bool = True,
|
||
pronunciation_dict: Optional[dict] = None,
|
||
) -> str:
|
||
if acronym_mode is None:
|
||
acronym_mode = "german" if lang == "de" else "period_space"
|
||
|
||
# 1. Aussprache-Wörterbuch zuerst (vor Akronym-Expansion, damit Eigennamen greifen)
|
||
if lang == "de":
|
||
text = apply_pronunciation_dict(text, DEFAULT_PRONUNCIATION_DE)
|
||
if pronunciation_dict:
|
||
text = apply_pronunciation_dict(text, pronunciation_dict)
|
||
|
||
if normalize_units_values:
|
||
text = normalize_units(text, lang)
|
||
|
||
if normalize_time_values:
|
||
text = normalize_times(text, lang)
|
||
|
||
if normalize_year_values:
|
||
text = normalize_years(text, lang)
|
||
|
||
if spell_uppercase_acronyms:
|
||
def repl_compound(match: re.Match) -> str:
|
||
acr = match.group(1)
|
||
if acr in NON_SPELLED_ACRONYMS:
|
||
return acr + " "
|
||
return spell_out_acronym(acr, mode=acronym_mode) + " "
|
||
|
||
def repl(match: re.Match) -> str:
|
||
token = match.group(0)
|
||
if token in NON_SPELLED_ACRONYMS:
|
||
return token
|
||
return spell_out_acronym(token, mode=acronym_mode)
|
||
|
||
# Compound zuerst: "US-Präsident" → "U Es Präsident" (Bindestrich weg)
|
||
text = ACRONYM_COMPOUND_RE.sub(repl_compound, text)
|
||
# Dann verbleibende Akronyme buchstabieren
|
||
text = UPPER_ACRONYM_RE.sub(repl, text)
|
||
|
||
text = re.sub(r'\s+', ' ', text).strip()
|
||
return text
|
||
|
||
|
||
def split_long_text(text: str, max_len: int = 400) -> List[str]:
|
||
chunks = []
|
||
current = ""
|
||
|
||
for part in text.split("\n\n"):
|
||
part = part.strip()
|
||
if not part:
|
||
continue
|
||
|
||
sentences = SENTENCE_END_RE.findall(part)
|
||
|
||
consumed = "".join(sentences).strip()
|
||
rest = part[len(consumed):].strip()
|
||
if rest:
|
||
sentences.append(rest)
|
||
|
||
for sentence in sentences:
|
||
sentence = sentence.strip()
|
||
if not sentence:
|
||
continue
|
||
|
||
if len(sentence) > max_len:
|
||
if current:
|
||
chunks.append(current.strip())
|
||
current = ""
|
||
|
||
chunks.extend(force_split_sentence(sentence, max_len))
|
||
continue
|
||
|
||
if current and len(current) + 1 + len(sentence) > max_len:
|
||
chunks.append(current.strip())
|
||
current = sentence
|
||
else:
|
||
current = f"{current} {sentence}".strip() if current else sentence
|
||
|
||
if current:
|
||
chunks.append(current.strip())
|
||
current = ""
|
||
|
||
return chunks
|
||
|
||
|
||
def split_for_conversation(text: str, first_chunk_len: int = 120, max_len: int = 400) -> List[str]:
|
||
base_chunks = split_long_text(text, max_len=max_len)
|
||
if not base_chunks:
|
||
return []
|
||
|
||
first = base_chunks[0]
|
||
if len(first) <= first_chunk_len:
|
||
return base_chunks
|
||
|
||
early = force_split_sentence(first, first_chunk_len)
|
||
return early + base_chunks[1:]
|
||
|
||
|
||
def force_split_sentence(text: str, max_len: int) -> List[str]:
|
||
text = re.sub(r"\s+", " ", text).strip()
|
||
if len(text) <= max_len:
|
||
return [text]
|
||
|
||
parts = []
|
||
remaining = text
|
||
|
||
while len(remaining) > max_len:
|
||
split_pos = remaining.rfind(" ", 0, max_len + 1)
|
||
if split_pos <= 0:
|
||
split_pos = max_len
|
||
parts.append(remaining[:split_pos].strip())
|
||
remaining = remaining[split_pos:].strip()
|
||
|
||
if remaining:
|
||
parts.append(remaining)
|
||
|
||
return parts
|
||
|
||
|
||
def split_into_sentences(text: str, max_len: int = 200) -> List[str]:
|
||
result = []
|
||
for part in text.split("\n\n"):
|
||
part = part.strip()
|
||
if not part:
|
||
continue
|
||
if SEPARATOR_LINE_RE.match(part):
|
||
continue
|
||
sentences = SENTENCE_END_RE.findall(part)
|
||
consumed = "".join(sentences).strip()
|
||
rest = part[len(consumed):].strip()
|
||
if rest:
|
||
sentences.append(rest)
|
||
for sentence in sentences:
|
||
sentence = sentence.strip()
|
||
if not sentence:
|
||
continue
|
||
if len(sentence) > max_len:
|
||
result.extend(force_split_sentence(sentence, max_len))
|
||
else:
|
||
result.append(sentence)
|
||
return result
|
||
|
||
|
||
def read_input_text(text_arg: Optional[str], input_path: Optional[str]) -> str:
|
||
if text_arg and input_path:
|
||
raise ValueError("Bitte entweder --text oder --input angeben, nicht beides.")
|
||
if not text_arg and not input_path:
|
||
raise ValueError("Bitte --text oder --input angeben.")
|
||
|
||
if text_arg:
|
||
return text_arg.strip()
|
||
|
||
path = Path(input_path)
|
||
if not path.exists():
|
||
raise FileNotFoundError(f"Input-Datei nicht gefunden: {path}")
|
||
|
||
return path.read_text(encoding="utf-8").strip()
|
||
|
||
|
||
def default_output_path(input_path: Optional[str], lang: str) -> Path:
|
||
if input_path:
|
||
src = Path(input_path)
|
||
return src.with_suffix(f".{lang}.wav")
|
||
return Path(f"tts_output.{lang}.wav")
|
||
|
||
|
||
def load_model(lang: str, device: str, t3_model: Optional[str] = None):
|
||
if lang == "en":
|
||
model = ChatterboxTTS.from_pretrained(device=device)
|
||
return model, "mono", model.sr
|
||
|
||
if not HAS_MULTILINGUAL:
|
||
raise RuntimeError(
|
||
"Multilingual-Modell nicht verfügbar. Installiere ein Chatterbox-Paket mit chatterbox.mtl_tts."
|
||
)
|
||
|
||
model = ChatterboxMultilingualTTS.from_pretrained(device=device, t3_model=t3_model)
|
||
return model, "multi", model.sr
|
||
|
||
|
||
def generate_chunk(model, model_kind: str, text: str, lang: str, voice_path: Optional[str]):
|
||
kwargs = {}
|
||
if voice_path:
|
||
kwargs["audio_prompt_path"] = voice_path
|
||
|
||
if model_kind == "mono":
|
||
return model.generate(text, **kwargs)
|
||
|
||
return model.generate(text, language_id=lang, **kwargs)
|
||
|
||
|
||
def generate_stream_chunk(
|
||
model,
|
||
model_kind: str,
|
||
text: str,
|
||
lang: str,
|
||
voice_path: Optional[str],
|
||
stream_chunk_size: int,
|
||
):
|
||
kwargs = {
|
||
"chunk_size": stream_chunk_size,
|
||
"print_metrics": False,
|
||
}
|
||
if voice_path:
|
||
kwargs["audio_prompt_path"] = voice_path
|
||
|
||
if model_kind == "mono":
|
||
return model.generate_stream(text, **kwargs)
|
||
|
||
return model.generate_stream(text, language_id=lang, **kwargs)
|
||
|
||
|
||
class PlaybackWorker:
|
||
PLAYBACK_RATE = 48000 # PipeWire/PulseAudio standard
|
||
CALLBACK_BLOCK = 2048 # ~43 ms pro Callback-Block bei 48 kHz
|
||
|
||
def __init__(self, sample_rate: int, device: Optional[str] = "pulse", speed: float = 1.0):
|
||
self.sample_rate = sample_rate
|
||
self.device = device
|
||
self.speed = speed
|
||
# Eingang: Torch-Tensoren vom TTS-Modell
|
||
self.audio_queue: "queue.Queue[Optional[torch.Tensor]]" = queue.Queue()
|
||
# Intern: fertig vorbereitete numpy-Blöcke für den Callback
|
||
self._block_queue: "queue.Queue" = queue.Queue(maxsize=500)
|
||
self._blocks_produced = 0
|
||
self._blocks_consumed = 0
|
||
self.thread = None
|
||
self.error = None
|
||
|
||
def start(self):
|
||
if not has_module("sounddevice"):
|
||
raise RuntimeError(
|
||
"Für Live-Wiedergabe ist das Modul 'sounddevice' nötig. Installiere z. B. 'pip install sounddevice'."
|
||
)
|
||
self.thread = threading.Thread(target=self._run, daemon=True)
|
||
self.thread.start()
|
||
|
||
def _callback(self, outdata, frames, time_info, status):
|
||
# Läuft im Audio-Thread: so schnell wie möglich, kein Lock nötig.
|
||
try:
|
||
data = self._block_queue.get_nowait()
|
||
outdata[:, 0] = data
|
||
self._blocks_consumed += 1
|
||
except queue.Empty:
|
||
outdata[:] = 0.0 # Stille statt Underrun-Klick
|
||
|
||
def _produce(self):
|
||
"""Wandelt Torch-Tensoren in CALLBACK_BLOCK-große numpy-Arrays um."""
|
||
import numpy as np
|
||
|
||
remainder = np.zeros(0, dtype="float32")
|
||
|
||
while True:
|
||
item = self.audio_queue.get()
|
||
if item is None:
|
||
break
|
||
|
||
chunk = item.detach().cpu()
|
||
if chunk.ndim == 2:
|
||
chunk = chunk.squeeze(0)
|
||
|
||
if self.speed != 1.0:
|
||
import pyrubberband as pyrb
|
||
# R3-Engine (--fine): deutlich weniger Phasiness als R2, besser für Sprache.
|
||
# rate < 1.0 = langsamer, rate > 1.0 = schneller; Pitch bleibt gleich.
|
||
stretched = pyrb.time_stretch(
|
||
chunk.numpy().astype("float64"), self.sample_rate, self.speed,
|
||
rbargs={"--fine": ""},
|
||
)
|
||
chunk = torch.from_numpy(stretched.astype("float32"))
|
||
|
||
chunk = ta.functional.resample(chunk, self.sample_rate, self.PLAYBACK_RATE)
|
||
|
||
samples = np.concatenate([remainder, chunk.numpy().astype("float32")])
|
||
|
||
i = 0
|
||
while i + self.CALLBACK_BLOCK <= len(samples):
|
||
self._block_queue.put(samples[i : i + self.CALLBACK_BLOCK])
|
||
self._blocks_produced += 1
|
||
i += self.CALLBACK_BLOCK
|
||
remainder = samples[i:]
|
||
|
||
# Restliche Samples (< CALLBACK_BLOCK) mit Stille auffüllen
|
||
if len(remainder) > 0:
|
||
block = np.zeros(self.CALLBACK_BLOCK, dtype="float32")
|
||
block[: len(remainder)] = remainder
|
||
self._block_queue.put(block)
|
||
self._blocks_produced += 1
|
||
|
||
def _run(self):
|
||
try:
|
||
import sounddevice as sd
|
||
|
||
producer = threading.Thread(target=self._produce, daemon=True)
|
||
producer.start()
|
||
|
||
with sd.OutputStream(
|
||
samplerate=self.PLAYBACK_RATE,
|
||
channels=1,
|
||
dtype="float32",
|
||
device=self.device,
|
||
blocksize=self.CALLBACK_BLOCK,
|
||
callback=self._callback,
|
||
):
|
||
producer.join() # alle Tensoren sind zu Blöcken konvertiert
|
||
|
||
# Warten bis der Callback alle Blöcke abgespielt hat
|
||
while self._blocks_consumed < self._blocks_produced:
|
||
time.sleep(0.02)
|
||
|
||
# Letzten Block aus Hardware-Buffer ausspielen lassen
|
||
time.sleep(self.CALLBACK_BLOCK / self.PLAYBACK_RATE + 0.1)
|
||
|
||
except Exception as e:
|
||
self.error = e
|
||
|
||
def put(self, chunk: torch.Tensor):
|
||
self.audio_queue.put(chunk)
|
||
|
||
def stop(self):
|
||
self.audio_queue.put(None)
|
||
if self.thread:
|
||
self.thread.join()
|
||
if self.error:
|
||
raise RuntimeError(f"Fehler bei Live-Wiedergabe: {self.error}")
|
||
|
||
|
||
def synthesize_non_streaming(
|
||
text: str,
|
||
lang: str,
|
||
output_path: Optional[Path],
|
||
max_len: int,
|
||
first_chunk_len: int,
|
||
voice_path: Optional[str],
|
||
device: str,
|
||
show_progress: bool = True,
|
||
spell_uppercase_acronyms: bool = True,
|
||
acronym_mode: Optional[str] = None,
|
||
normalize_time_values: bool = True,
|
||
normalize_year_values: bool = True,
|
||
normalize_units_values: bool = True,
|
||
conversation_mode: bool = True,
|
||
play_audio: bool = False,
|
||
save_wav: bool = True,
|
||
audio_device: Optional[str] = "pulse",
|
||
sentence_mode: bool = True,
|
||
speed: float = 1.0,
|
||
debug_delay: float = 0.0,
|
||
t3_model: Optional[str] = None,
|
||
pronunciation_dict: Optional[dict] = None,
|
||
) -> Optional[Path]:
|
||
if lang not in SUPPORTED_LANGS:
|
||
raise ValueError(
|
||
f"Nicht unterstützte Sprache '{lang}'. Unterstützt: {', '.join(sorted(SUPPORTED_LANGS))}"
|
||
)
|
||
|
||
if voice_path and not Path(voice_path).exists():
|
||
raise FileNotFoundError(f"Voice-Referenz nicht gefunden: {voice_path}")
|
||
|
||
# Erst unsichtbare Zeichen entfernen, dann Sätze splitten (Paragraphen-Struktur erhalten),
|
||
# danach erst Akronym-Expansion — sonst erzeugen "A. R. D."-Punkte falsche Satzgrenzen.
|
||
text = clean_raw_text(text)
|
||
|
||
model, model_kind, sr = load_model(lang, device, t3_model=t3_model)
|
||
|
||
if sentence_mode:
|
||
raw_chunks = split_into_sentences(text, max_len=max_len)
|
||
elif conversation_mode:
|
||
raw_chunks = split_for_conversation(text, first_chunk_len=first_chunk_len, max_len=max_len)
|
||
else:
|
||
raw_chunks = split_long_text(text, max_len=max_len)
|
||
|
||
preprocess_kw = dict(
|
||
lang=lang,
|
||
spell_uppercase_acronyms=spell_uppercase_acronyms,
|
||
acronym_mode=acronym_mode,
|
||
normalize_time_values=normalize_time_values,
|
||
normalize_year_values=normalize_year_values,
|
||
normalize_units_values=normalize_units_values,
|
||
pronunciation_dict=pronunciation_dict,
|
||
)
|
||
chunks = [preprocess_tts_text(c, **preprocess_kw) for c in raw_chunks]
|
||
chunks = [c for c in chunks if c.strip()]
|
||
|
||
if not chunks:
|
||
raise ValueError("Kein verwertbarer Text nach dem Einlesen gefunden.")
|
||
|
||
if show_progress:
|
||
print(f"Sprache: {lang}")
|
||
print(f"Gerät: {device}")
|
||
print(f"Modell: {'ChatterboxTTS (monolingual)' if model_kind == 'mono' else 'ChatterboxMultilingualTTS'}")
|
||
print(f"Sätze: {len(chunks)}")
|
||
print(f"Modus: {'Satz-für-Satz' if sentence_mode else 'non-streaming'} + Playback")
|
||
print(f"Live-Wiedergabe: {'ja' if play_audio else 'nein'}")
|
||
print(f"WAV speichern: {'ja' if save_wav and output_path else 'nein'}")
|
||
if output_path and save_wav:
|
||
print(f"Ausgabe: {output_path}")
|
||
|
||
if play_audio:
|
||
playback = PlaybackWorker(sample_rate=sr, device=audio_device, speed=speed)
|
||
playback.start()
|
||
else:
|
||
playback = None
|
||
|
||
wavs = []
|
||
try:
|
||
for i, chunk in enumerate(chunks, start=1):
|
||
if debug_delay > 0:
|
||
if show_progress:
|
||
print(f"[{i}/{len(chunks)}] Warte {debug_delay:.0f}s (debug_delay) ...")
|
||
time.sleep(debug_delay)
|
||
if show_progress:
|
||
print(f"[{i}/{len(chunks)}] Generiere ({len(chunk)} Zeichen) ...")
|
||
wav = generate_chunk(model, model_kind, chunk, lang, voice_path)
|
||
wavs.append(wav)
|
||
if playback is not None:
|
||
playback.put(wav)
|
||
finally:
|
||
if playback is not None:
|
||
playback.stop()
|
||
|
||
if not wavs:
|
||
return None
|
||
|
||
final_wav = wavs[0] if len(wavs) == 1 else torch.cat(wavs, dim=-1)
|
||
|
||
if save_wav and output_path:
|
||
output_path.parent.mkdir(parents=True, exist_ok=True)
|
||
ta.save(str(output_path), final_wav, sr)
|
||
return output_path
|
||
|
||
return None
|
||
|
||
|
||
def synthesize_streaming(
|
||
text: str,
|
||
lang: str,
|
||
output_path: Optional[Path],
|
||
max_len: int,
|
||
first_chunk_len: int,
|
||
voice_path: Optional[str],
|
||
device: str,
|
||
show_progress: bool = True,
|
||
spell_uppercase_acronyms: bool = True,
|
||
acronym_mode: str = "period_space",
|
||
normalize_time_values: bool = True,
|
||
normalize_year_values: bool = True,
|
||
normalize_units_values: bool = True,
|
||
conversation_mode: bool = True,
|
||
play_audio: bool = True,
|
||
save_wav: bool = True,
|
||
stream_chunk_size: int = 25,
|
||
audio_device: Optional[str] = None,
|
||
) -> Optional[Path]:
|
||
if lang not in SUPPORTED_LANGS:
|
||
raise ValueError(
|
||
f"Nicht unterstützte Sprache '{lang}'. Unterstützt: {', '.join(sorted(SUPPORTED_LANGS))}"
|
||
)
|
||
|
||
if voice_path and not Path(voice_path).exists():
|
||
raise FileNotFoundError(f"Voice-Referenz nicht gefunden: {voice_path}")
|
||
|
||
text = preprocess_tts_text(
|
||
text=text,
|
||
lang=lang,
|
||
spell_uppercase_acronyms=spell_uppercase_acronyms,
|
||
acronym_mode=acronym_mode,
|
||
normalize_time_values=normalize_time_values,
|
||
normalize_year_values=normalize_year_values,
|
||
normalize_units_values=normalize_units_values,
|
||
)
|
||
|
||
model, model_kind, sr = load_model(lang, device)
|
||
|
||
if not hasattr(model, "generate_stream"):
|
||
raise RuntimeError(
|
||
"Dieses Chatterbox-Paket bietet kein generate_stream(). "
|
||
"Installiere z. B. 'chatterbox-streaming'."
|
||
)
|
||
|
||
if conversation_mode:
|
||
text_chunks = split_for_conversation(text, first_chunk_len=first_chunk_len, max_len=max_len)
|
||
else:
|
||
text_chunks = split_long_text(text, max_len=max_len)
|
||
|
||
if not text_chunks:
|
||
raise ValueError("Kein verwertbarer Text nach dem Einlesen gefunden.")
|
||
|
||
if play_audio:
|
||
playback = PlaybackWorker(sample_rate=sr, device=audio_device)
|
||
playback.start()
|
||
else:
|
||
playback = None
|
||
|
||
all_audio_chunks: List[torch.Tensor] = []
|
||
t0 = time.perf_counter()
|
||
first_audio_started = False
|
||
|
||
if show_progress:
|
||
print(f"Sprache: {lang}")
|
||
print(f"Gerät: {device}")
|
||
print(f"Modell: {'ChatterboxTTS (monolingual)' if model_kind == 'mono' else 'ChatterboxMultilingualTTS'}")
|
||
print(f"Text-Chunks: {len(text_chunks)}")
|
||
print(f"Modus: streaming")
|
||
print(f"Gesprächsmodus: {'ja' if conversation_mode else 'nein'}")
|
||
print(f"Live-Wiedergabe: {'ja' if play_audio else 'nein'}")
|
||
print(f"WAV speichern: {'ja' if save_wav and output_path else 'nein'}")
|
||
print(f"Streaming chunk_size: {stream_chunk_size}")
|
||
if output_path:
|
||
print(f"Ausgabe: {output_path}")
|
||
|
||
try:
|
||
for text_idx, text_chunk in enumerate(text_chunks, start=1):
|
||
if show_progress:
|
||
print(f"[Text {text_idx}/{len(text_chunks)}] Starte Streaming für {len(text_chunk)} Zeichen ...")
|
||
|
||
stream_iter = generate_stream_chunk(
|
||
model=model,
|
||
model_kind=model_kind,
|
||
text=text_chunk,
|
||
lang=lang,
|
||
voice_path=voice_path,
|
||
stream_chunk_size=stream_chunk_size,
|
||
)
|
||
|
||
for audio_idx, item in enumerate(stream_iter, start=1):
|
||
if isinstance(item, tuple) and len(item) == 2:
|
||
audio_chunk, metrics = item
|
||
else:
|
||
audio_chunk, metrics = item, None
|
||
|
||
all_audio_chunks.append(audio_chunk)
|
||
|
||
if playback is not None:
|
||
playback.put(audio_chunk)
|
||
if not first_audio_started:
|
||
first_audio_started = True
|
||
if show_progress:
|
||
dt = time.perf_counter() - t0
|
||
print(f"Audio-Wiedergabe gestartet nach {dt:.3f}s")
|
||
|
||
if show_progress:
|
||
msg = f" -> Audio-Chunk {audio_idx}"
|
||
if metrics is not None:
|
||
latency = getattr(metrics, "latency_to_first_chunk", None)
|
||
rtf = getattr(metrics, "rtf", None)
|
||
chunk_count = getattr(metrics, "chunk_count", None)
|
||
if chunk_count is not None:
|
||
msg += f", model_chunk={chunk_count}"
|
||
if latency:
|
||
msg += f", first_latency={latency:.3f}s"
|
||
if rtf:
|
||
msg += f", rtf={rtf:.3f}"
|
||
print(msg)
|
||
|
||
finally:
|
||
if playback is not None:
|
||
playback.stop()
|
||
|
||
final_output = None
|
||
if save_wav and output_path:
|
||
final_audio = all_audio_chunks[0] if len(all_audio_chunks) == 1 else torch.cat(all_audio_chunks, dim=-1)
|
||
output_path.parent.mkdir(parents=True, exist_ok=True)
|
||
ta.save(str(output_path), final_audio, sr)
|
||
final_output = output_path
|
||
|
||
return final_output
|
||
|
||
|
||
def build_argparser() -> argparse.ArgumentParser:
|
||
p = argparse.ArgumentParser(
|
||
description="Low-Latency Chatterbox TTS CLI mit deutscher Text-Normalisierung und optionalem Streaming."
|
||
)
|
||
p.add_argument("--text", type=str, help="Direkter Eingabetext.")
|
||
p.add_argument("--input", type=str, help="Pfad zu UTF-8-Textdatei.")
|
||
p.add_argument("--lang", type=str, default="de", help="Sprachcode, default: de.")
|
||
p.add_argument("--len", dest="max_len", type=int, default=400, help="Maximale Chunk-Länge, default: 400.")
|
||
p.add_argument("--first-chunk-len", type=int, default=80, help="Kleinere Zielgröße für den ersten Chunk im Gesprächsmodus. Default: 80.")
|
||
p.add_argument("--output", type=str, help="Ausgabedatei .wav")
|
||
p.add_argument("--voice", type=str, help="Optionale Referenz-WAV für Voice-Cloning.")
|
||
p.add_argument("--device", type=str, default=None, help="z. B. cuda:0 oder cpu.")
|
||
p.add_argument("--no-progress", action="store_true", help="Weniger Konsolen-Output.")
|
||
p.add_argument("--no-spell-acronyms", action="store_true", help="Großgeschriebene Akronyme nicht buchstabieren.")
|
||
p.add_argument(
|
||
"--acronym-mode",
|
||
type=str,
|
||
default=None, # None = automatisch: 'german' bei de, 'period_space' sonst
|
||
choices=["space", "period", "comma", "period_space", "german"],
|
||
help="Ausgabeformat für buchstabierte Akronyme. Default: 'german' bei --lang de, sonst 'period_space'."
|
||
)
|
||
p.add_argument("--pronunciation-dict", type=str, default=None, help="Pfad zu einer JSON-Datei mit Aussprache-Substitutionen (Eigenname → Lautschrift).")
|
||
p.add_argument("--no-normalize-times", action="store_true", help="Uhrzeiten nicht in sprechbaren Text umwandeln.")
|
||
p.add_argument("--no-normalize-years", action="store_true", help="Jahreszahlen nicht in sprechbaren Text umwandeln.")
|
||
p.add_argument("--no-normalize-units", action="store_true", help="Einheiten nicht in sprechbaren Text umwandeln.")
|
||
p.add_argument("--stream", action="store_true", help="Streaming-TTS-Modus (experimentell, kann abgehackt klingen).")
|
||
p.add_argument("--no-play", action="store_true", help="Nicht live abspielen.")
|
||
p.add_argument("--audio-device", type=str, default="pulse", help="Sounddevice-Ausgabegerät, z. B. 'pulse' oder 'M2: USB Audio'. Standard: pulse.")
|
||
p.add_argument("--save", action="store_true", help="WAV-Datei speichern (Standard: nein).")
|
||
p.add_argument("--stream-chunk-size", type=int, default=12, help="Streaming chunk_size (nur mit --stream). Default: 12.")
|
||
p.add_argument("--no-sentence-mode", action="store_true", help="Sätze zu größeren Chunks gruppieren statt einzeln ausgeben.")
|
||
p.add_argument("--speed", type=float, default=1.0, help="Wiedergabegeschwindigkeit: 0.8 = 20%% langsamer, 1.2 = 20%% schneller. Default: 1.0.")
|
||
p.add_argument("--debug-delay", type=float, default=0.0, help="Sekunden Pause vor jedem Satz (simuliert langsame KI). Nur zum Testen.")
|
||
p.add_argument("--t3-model", type=str, default="v3", help="Multilingual T3-Modell: 'v3' (default), 'v2' oder Dateiname.")
|
||
p.add_argument("--no-conversation-mode", action="store_true", help="Ersten Chunk nicht künstlich kleiner machen (nur ohne --no-sentence-mode).")
|
||
return p
|
||
|
||
|
||
def main() -> int:
|
||
parser = build_argparser()
|
||
args = parser.parse_args()
|
||
|
||
try:
|
||
text = read_input_text(args.text, args.input)
|
||
device = get_device(args.device)
|
||
output_path = Path(args.output) if args.output else default_output_path(args.input, args.lang)
|
||
|
||
save_wav = args.save or bool(args.output)
|
||
|
||
# Acronym-Mode-Default: 'german' bei Deutsch, 'period_space' sonst
|
||
acronym_mode = args.acronym_mode or ("german" if args.lang == "de" else "period_space")
|
||
|
||
# Optionales Aussprache-Wörterbuch laden
|
||
pronunciation_dict: Optional[dict] = None
|
||
if args.pronunciation_dict:
|
||
import json
|
||
pron_path = Path(args.pronunciation_dict)
|
||
if not pron_path.exists():
|
||
raise FileNotFoundError(f"Aussprache-Dict nicht gefunden: {pron_path}")
|
||
pronunciation_dict = json.loads(pron_path.read_text(encoding="utf-8"))
|
||
|
||
if args.stream:
|
||
out = synthesize_streaming(
|
||
text=text,
|
||
lang=args.lang,
|
||
output_path=output_path if save_wav else None,
|
||
max_len=args.max_len,
|
||
first_chunk_len=args.first_chunk_len,
|
||
voice_path=args.voice,
|
||
device=device,
|
||
show_progress=not args.no_progress,
|
||
spell_uppercase_acronyms=not args.no_spell_acronyms,
|
||
acronym_mode=acronym_mode,
|
||
normalize_time_values=not args.no_normalize_times,
|
||
normalize_year_values=not args.no_normalize_years,
|
||
normalize_units_values=not args.no_normalize_units,
|
||
conversation_mode=not args.no_conversation_mode,
|
||
play_audio=not args.no_play,
|
||
save_wav=save_wav,
|
||
stream_chunk_size=args.stream_chunk_size,
|
||
audio_device=args.audio_device,
|
||
)
|
||
else:
|
||
out = synthesize_non_streaming(
|
||
text=text,
|
||
lang=args.lang,
|
||
output_path=output_path if save_wav else None,
|
||
max_len=args.max_len,
|
||
first_chunk_len=args.first_chunk_len,
|
||
voice_path=args.voice,
|
||
device=device,
|
||
show_progress=not args.no_progress,
|
||
spell_uppercase_acronyms=not args.no_spell_acronyms,
|
||
acronym_mode=acronym_mode,
|
||
normalize_time_values=not args.no_normalize_times,
|
||
normalize_year_values=not args.no_normalize_years,
|
||
normalize_units_values=not args.no_normalize_units,
|
||
conversation_mode=not args.no_conversation_mode,
|
||
play_audio=not args.no_play,
|
||
save_wav=save_wav,
|
||
audio_device=args.audio_device,
|
||
sentence_mode=not args.no_sentence_mode,
|
||
speed=args.speed,
|
||
debug_delay=args.debug_delay,
|
||
t3_model=args.t3_model,
|
||
pronunciation_dict=pronunciation_dict,
|
||
)
|
||
|
||
if out is not None:
|
||
print(f"Fertig: {out}")
|
||
else:
|
||
print("Fertig.")
|
||
return 0
|
||
|
||
except Exception as e:
|
||
print(f"Fehler: {e}", file=sys.stderr)
|
||
return 1
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|
||
|