Initial commit: chatterbox TTS CLI v4

This commit is contained in:
Dieter Schlüter 2026-05-16 08:56:50 +02:00
commit bed29fb1c8
6 changed files with 1434 additions and 0 deletions

27
.gitignore vendored Normal file
View file

@ -0,0 +1,27 @@
# Python
__pycache__/
*.py[cod]
*.egg-info/
.eggs/
# Ausgabe-Dateien
*.wav
*.mp3
*.ogg
# Persönliche Daten (Stimmaufnahmen)
my_voice*.wav
voice_*.wav
# Umgebung
.env
*.log
.venv/
env/
# IDE
.vscode/
.idea/
# Claude Code
.claude/

200
BEDIENUNGSANLEITUNG.md Normal file
View file

@ -0,0 +1,200 @@
# Bedienungsanleitung: Chatterbox TTS-Assistent
Dieses Programm liest Texte laut vor — ähnlich wie ein Vorlesedienst.
Es wandelt geschriebenen Text in natürlich klingende Sprache um.
---
## Was das Programm braucht
- Einen Computer mit Linux
- Eine installierte Conda-Umgebung namens `chatterbox`
- Eine Grafikkarte (GPU) — macht das Programm deutlich schneller
---
## Das Programm starten
Öffne ein Terminal und gib folgende Befehle ein:
```bash
conda activate chatterbox
cd ~/Python_Programs/chatterbox
```
---
## Einen Text vorlesen lassen
### Text aus einer Datei vorlesen
```bash
python chatterbox_cli_v4.py --lang de --input mein_text.txt
```
Ersetze `mein_text.txt` durch den Pfad zu deiner Textdatei.
Die Datei muss im Format **UTF-8** gespeichert sein (das ist der Standard
bei modernen Texteditoren).
### Einen kurzen Text direkt eingeben
```bash
python chatterbox_cli_v4.py --lang de --text "Guten Morgen! Wie geht es Ihnen heute?"
```
---
## Die eigene Stimme verwenden
Wenn du eine Aufnahme deiner Stimme hast (eine WAV-Datei von ca. 1030 Sekunden),
kann das Programm diese Stimme nachahmen:
```bash
python chatterbox_cli_v4.py --lang de \
--voice meine_stimme.wav \
--input mein_text.txt
```
**Tipp:** Eine Aufnahme von 20 Sekunden reicht aus. Am besten in ruhiger Umgebung
und deutlich sprechen.
---
## Sprache wählen
Das Programm kann in vielen Sprachen vorlesen. Die Sprache wählt man mit `--lang`:
| Befehl | Sprache |
|--------|---------|
| `--lang de` | Deutsch (Standard) |
| `--lang en` | Englisch |
| `--lang fr` | Französisch |
| `--lang es` | Spanisch |
| `--lang it` | Italienisch |
Beispiel auf Englisch:
```bash
python chatterbox_cli_v4.py --lang en --text "Good morning, how are you?"
```
---
## Sprechgeschwindigkeit anpassen
Mit `--speed` kann man einstellen, wie schnell der Text gesprochen wird.
- `1.0` = normale Geschwindigkeit (Standard)
- `0.85` = etwas langsamer — gut für ältere Hörer
- `0.75` = deutlich langsamer
- `1.2` = etwas schneller
```bash
python chatterbox_cli_v4.py --lang de --speed 0.85 --input mein_text.txt
```
**Hinweis:** Die Stimmhöhe bleibt gleich — nur das Tempo ändert sich.
---
## Audio als Datei speichern
Wenn du die Audiodatei behalten möchtest:
```bash
python chatterbox_cli_v4.py --lang de --save --input mein_text.txt
```
Die Datei wird automatisch als `mein_text.de.wav` gespeichert — im selben
Ordner wie die Eingabedatei.
Oder mit eigenem Dateinamen:
```bash
python chatterbox_cli_v4.py --lang de --output ausgabe.wav --input mein_text.txt
```
---
## Nur speichern, nicht abspielen
```bash
python chatterbox_cli_v4.py --lang de --no-play --output ausgabe.wav --input mein_text.txt
```
---
## Aussprache von Eigennamen anpassen
Manche Namen — vor allem aus anderen Sprachen — werden falsch ausgesprochen.
Du kannst das mit einer einfachen Textdatei im JSON-Format korrigieren.
**Beispiel:** Datei `aussprache.json` anlegen:
```json
{
"Xi Jinping": "Schi Dschinping",
"Seoul": "Söul",
"Macron": "Makron"
}
```
Dann so aufrufen:
```bash
python chatterbox_cli_v4.py --lang de \
--pronunciation-dict aussprache.json \
--input nachricht.txt
```
---
## Typischer Arbeitsablauf
1. Text in einem Editor schreiben und als `.txt`-Datei speichern
2. Terminal öffnen, `conda activate chatterbox`
3. Programm aufrufen:
```bash
python chatterbox_cli_v4.py --lang de --voice meine_stimme.wav --input text.txt
```
4. Das Programm beginnt sofort zu sprechen — Satz für Satz
---
## Was das Programm automatisch macht
- Abkürzungen buchstabieren: ARD wird zu „Ah Er De", YMCA zu „Ypsilon Em Tse Ah"
- Zusammengesetzte Wörter mit Abkürzung: „US-Präsident" wird zu „U Es Präsident"
- Uhrzeiten vorlesen: „14:58" wird zu „vierzehn Uhr achtundfünfzig"
- Jahreszahlen aussprechen: „2026" wird zu „zweitausendsechsundzwanzig"
- Trennzeilen wie „--- Ende ---" werden stillschweigend übersprungen
---
## Wenn etwas nicht klappt
**Kein Ton zu hören:**
```bash
# Ausgabegerät prüfen
python -c "import sounddevice; print(sounddevice.query_devices())"
```
Dann `--audio-device pulse` oder das passende Gerät angeben.
**„Modell nicht gefunden":**
Beim ersten Start wird das Modell heruntergeladen (~2 GB).
Sicherstellen, dass eine Internetverbindung besteht.
**Programm ist sehr langsam:**
Ohne GPU dauert die Generierung länger als die Wiedergabe — ein Satz
kann 3060 Sekunden brauchen. Mit GPU (CUDA) dauert es ca. 510 Sekunden.
---
## Bekannte Grenzen
- **Betonung einzelner Wörter** lässt sich nicht direkt steuern.
Eine Aufnahme der eigenen Stimme mit natürlicher Betonung kann helfen.
- **Manche Fremdwörter** (z. B. chinesische oder arabische Namen) klingen
nicht immer perfekt — mit der Aussprache-Datei lässt sich das korrigieren.
- Das Programm liest alles vor, was in der Datei steht — also auch
Überschriften und Metadaten wie „Schlagzeile:" oder „Stand:".

139
README.md Normal file
View file

@ -0,0 +1,139 @@
# chatterbox-tts-cli
Ein kommandozeilenbasierter TTS-Assistent (Text-to-Speech) auf Basis von
[Chatterbox TTS](https://github.com/resemble-ai/chatterbox) (Resemble AI).
Optimiert für deutsche Sprache und den Einsatz als Audio-Vorlesehilfe, z. B.
für Senioren oder Accessibility-Anwendungen.
## Features
- **Satz-für-Satz-Streaming** — gibt den ersten Satz aus, während die nächsten
bereits generiert werden; minimale Latenz
- **Lückenlose Audiowiedergabe** — Callback-basierter OutputStream mit
vorgefertigten Blöcken; keine Unterbrechungen zwischen Sätzen
- **Geschwindigkeitsanpassung** — pitch-erhaltende Zeitstreckung via
pyrubberband (R3-Engine); konfigurierbar per `--speed`
- **Voice Cloning** — optionale WAV-Referenz für Akzent und Klang
- **Mehrsprachig** — Deutsch, Englisch und 20+ weitere Sprachen via
`ChatterboxMultilingualTTS` (erfordert Multilingual-Setup, s. u.)
- **Deutsche Textnormalisierung**
- Abkürzungen: ARD → "Ah Er De", YMCA → "Ypsilon Em Tse Ah"
- Komposita: US-Präsident → "U Es Präsident"
- Uhrzeiten: 14:58 → "vierzehn Uhr achtundfünfzig"
- Jahreszahlen: 2026 → "zweitausendsechsundzwanzig"
- Einheiten: 120 km/h → "120 Kilometer pro Stunde"
- **Konfigurierbares Aussprache-Wörterbuch** — Eigennamen und Fremdwörter
per JSON-Datei phonetisch überschreiben
- **Automatische Satz-Erkennung** — intelligentes Splitting inkl.
Ordinalzahlen, Paragraphen und Trennzeilen
## Systemvoraussetzungen
- Python 3.11+
- CUDA-GPU empfohlen (RTX 3070 oder besser; CPU möglich aber langsam)
- Linux mit PipeWire oder PulseAudio (für `--audio-device pulse`)
- `rubberband-cli` (nur wenn `--speed` != 1.0 genutzt wird):
```bash
sudo apt install rubberband-cli
```
## Installation
```bash
# 1. Conda-Umgebung erstellen (empfohlen)
conda create -n chatterbox python=3.11
conda activate chatterbox
# 2. PyTorch mit CUDA installieren (Beispiel für CUDA 12.4)
pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu124
# 3. Chatterbox und weitere Abhängigkeiten
pip install chatterbox-tts sounddevice pyrubberband
# 4. Skript herunterladen
# chatterbox_cli_v4.py in das Arbeitsverzeichnis legen
```
### Multilingual-Setup (für Deutsch und andere Nicht-Englisch-Sprachen)
Das Standard-Paket `chatterbox-tts` enthält die Multilingual-Unterstützung
noch nicht vollständig. Notwendige Schritte:
```bash
# Multilingual-Modell herunterladen (beim ersten Start automatisch)
# Modell-Auswahl: v3 (Standard, besser) oder v2
# Wird in ~/.cache/huggingface/ gespeichert
```
Beim ersten Start mit `--lang de` werden die Modelle automatisch heruntergeladen
(ca. 23 GB).
## Schnellstart
```bash
# Deutschen Text vorlesen (aus Datei)
python chatterbox_cli_v4.py --lang de --input mein_text.txt
# Mit eigener Stimme (Voice Cloning)
python chatterbox_cli_v4.py --lang de \
--voice meine_stimme.wav \
--input mein_text.txt
# Etwas langsamer sprechen
python chatterbox_cli_v4.py --lang de --speed 0.85 --input mein_text.txt
# Englisch
python chatterbox_cli_v4.py --lang en --text "Hello, how are you today?"
```
## Optionen
| Option | Standard | Beschreibung |
|--------|----------|--------------|
| `--text TEXT` | — | Text direkt als Argument |
| `--input DATEI` | — | UTF-8-Textdatei als Eingabe |
| `--lang CODE` | `de` | Sprachcode (de, en, fr, es, …) |
| `--voice DATEI.wav` | — | Referenz-WAV für Voice Cloning |
| `--speed 0.85` | `1.0` | Geschwindigkeit (0.71.3); pitch bleibt gleich |
| `--audio-device` | `pulse` | Ausgabegerät (z. B. `pulse`, `default`) |
| `--t3-model` | `v3` | Multilingual-Modell: `v3` oder `v2` |
| `--acronym-mode` | `german` | Akronym-Modus: `german`, `space`, `period_space` |
| `--pronunciation-dict` | — | JSON-Datei mit Aussprache-Substitutionen |
| `--save` | nein | WAV-Datei speichern |
| `--output DATEI.wav` | — | Ausgabepfad (impliziert `--save`) |
| `--no-play` | — | Nur speichern, nicht abspielen |
| `--no-sentence-mode` | — | Text als Ganzes statt satzweise verarbeiten |
| `--debug-delay N` | `0` | Pause in Sekunden vor jedem Satz (zum Testen) |
| `--speed` | `1.0` | Sprechgeschwindigkeit |
## Aussprache-Wörterbuch
Für Eigennamen und Fremdwörter, die das Modell falsch ausspricht:
```json
{
"Xi Jinping": "Schi Dschinping",
"Putin": "Pjutin",
"Seoul": "Söul"
}
```
```bash
python chatterbox_cli_v4.py --lang de \
--pronunciation-dict aussprache.json \
--input nachricht.txt
```
## Bekannte Einschränkungen
- **Wortbetonung** lässt sich nicht steuern — das Modell kennt kein SSML.
Abhilfe: Voice-Referenz mit gewünschter Betonung aufnehmen.
- **Chinesische/japanische Namen** werden phonetisch angenähert; das Modell
ist nicht für asiatische Phonetik optimiert.
- **Sehr lange Texte** werden satzweise verarbeitet; zwischen Absätzen können
kurze Pausen entstehen (Generierungszeit für den nächsten Satz).
## Lizenz
MIT — dieses Skript. Das Chatterbox-Modell unterliegt der MIT-Lizenz von
Resemble AI. Die Modellgewichte sind nicht-kommerziell (CC BY-NC 4.0).

18
Trump_in_China_kurz.txt Normal file
View file

@ -0,0 +1,18 @@
Schlagzeile: Die neue Harmonie - mit Schlagseite
Stand: 15. Mai 2026 - 14:58
Unterschlagzeile: Ein Besuch in großer Eintracht, so hatte es US-Präsident Trump schon vor Abreise nach China versprochen, und so kam es auch. Doch der Eindruck bleibt, dass die Gegenleistung überschaubar ausfällt.
Eine Analyse von Marie von Mallinckrodt, ARD Peking
Die Blaskapelle der Volksbefreiungsarmee spielt eine Version von "YMCA", eines der Lieblingslieder von US-Präsident Donald Trump. Serviert wird Lobster in Tomatensuppe, Peking-Ente und vieles mehr. Gegessen wird mit goldenem Besteck. Die Stimmung beim pompösen Staatsbankett in der Halle des Volkes ist feierlich und freundlich. Zwei ehemalige Rivalen stoßen auf ihre Annäherung an. Es ist diese Aussage des chinesischen Staats- und Parteichefs Xi Jinping an diesem Abend, die den Wesenskern der Beziehung der beiden Staatsoberhäupter wohl am besten beschreibt: "Die große Wiederbelebung der chinesischen Nation und das Ziel 'Make America great again' können Hand in Hand gehen. Wir können uns gegenseitig zum Erfolg verhelfen."
Zwischenzeile: Beide können zufrieden sein
Sowohl Xi als auch Trump führen eine nationalistische und auf Eigeninteressen bedachte Außenpolitik. Mit dem Unterschied, dass Xi einen langfristigen, strategischen Plan hat, wie er die "Wiederbelebung der Nation" erreichen will und Trump ein eher impulsives Deal-Making betreibt. Xi möchte China gern bis 2049 zur dominierenden, globalen Supermacht machen. So betrachtet fällt die Bilanz des zweitägigen Treffens ganz offenbar für beide nicht schlecht aus, wenn man die beiden wichtigsten Krisenfelder aus ihrer jeweiligen Perspektive betrachtet: Handel und Geopolitik.
--- Ende ---

1033
chatterbox_cli_v4.py Executable file

File diff suppressed because it is too large Load diff

17
requirements.txt Normal file
View file

@ -0,0 +1,17 @@
# Chatterbox TTS CLI — Abhängigkeiten
# Getestet mit Python 3.11, CUDA 12.x, Ubuntu 22.04/24.04
# TTS-Kern
chatterbox-tts>=0.1.7
# PyTorch (passende CUDA-Version separat installieren, z. B. via pytorch.org)
torch>=2.6.0
torchaudio>=2.6.0
# Audio-Ausgabe (Linux/PipeWire/PulseAudio)
sounddevice>=0.4.0
# Pitch-erhaltende Zeitstreckung (Geschwindigkeitsanpassung)
pyrubberband>=0.4.0
# rubberband-cli muss zusätzlich als Systempakete installiert sein:
# sudo apt install rubberband-cli