Is it possible to create a dialogue - two different voices?

[radionome]

Hello,

I've been tinkering with Kokoro and and googled for a bit but I wasn't able to find a way to create a dialogue between two or more people.

Is there a kind of notation I can use to do that? If not, is it possible to add this as a feature?

Thanks in advance!

[Patrick-Ric]

You can use a text file with control characters. I had Gronk3 create a complete Python GUI for me, which can do adjustable voice weighting, speaking speed, pause times after each sentence and batch processing for several jobs in parallel and much more.
This GUI then reads in textfiles in which the voice and additional pause times can be inserted using control characters like:
[voice=custom_mix]
[pause=1.3]
Chapter 1: two hundred voices.
[pause=1.3]
[voice=af_heart]

[Patrick-Ric]

The GUI works great, I can't program myself, it was all done by Gronk3.
But until it was finished and everything worked, it took some time, because I also had to submit error reports, and Gronk3 then corrected the code, and that several times and sometimes I had to enter something in the console.
I can provide the Phyton code, you can also give it to Gronk and have the interface changed to English and add more functions if necessary.

[Patrick-Ric]

import sys
import os
import json
import time
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
QLabel, QLineEdit, QPushButton, QFileDialog, QTableWidget,
QTableWidgetItem, QProgressBar, QDoubleSpinBox, QScrollArea,
QCheckBox, QMessageBox)
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QTimer
import soundfile as sf
import numpy as np
import re
from tqdm import tqdm
import torch
from kokoro_onnx import Kokoro

print("DEBUG: Skript gestartet, importiere Module...")

class TTSThread(QThread):
log_signal = pyqtSignal(str)
progress_signal = pyqtSignal(int, int) # process_id, progress
time_signal = pyqtSignal(int, str) # process_id, time_info
status_signal = pyqtSignal(int, str) # process_id, status
finished_signal = pyqtSignal(int, bool) # process_id, was_canceled
error_signal = pyqtSignal(int, str)

def __init__(self, process_id, input_file, output_file, sentence_pause_duration, speed, voice_weights):
    super().__init__()
    self.process_id = process_id
    self.input_file = input_file
    self.output_file = output_file
    self.sentence_pause_duration = sentence_pause_duration
    self.speed = speed
    self.voice_weights = voice_weights
    self._stop = False
    self._was_canceled = False
    self._paused = False
    self.start_time = None
    self.pause_start_time = None
    self.total_pause_duration = 0

def stop(self):
    print(f"DEBUG: [Prozess {self.process_id}] Stop-Signal empfangen.")
    self._stop = True
    self._was_canceled = True

def pause(self):
    if not self._paused:
        print(f"DEBUG: [Prozess {self.process_id}] Pausieren-Signal empfangen.")
        self._paused = True
        self.pause_start_time = time.time()
        self.status_signal.emit(self.process_id, "Pausiert")
    else:
        print(f"DEBUG: [Prozess {self.process_id}] Fortführen-Signal empfangen.")
        if self.pause_start_time is not None:
            pause_duration = time.time() - self.pause_start_time
            self.total_pause_duration += pause_duration
            self.pause_start_time = None
        self._paused = False
        self.status_signal.emit(self.process_id, "Läuft")

def format_time(self, seconds):
    """Konvertiert Sekunden in HH:MM:SS Format."""
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    secs = int(seconds % 60)
    return f"{hours:02d}:{minutes:02d}:{secs:02d}"

def run(self):
    try:
        self.start_time = time.time()
        print(f"DEBUG: [Prozess {self.process_id}] Initialisiere Kokoro...")
        self.log_signal.emit(f"[Prozess {self.process_id}] Initialisiere Kokoro...")
        kokoro = Kokoro("kokoro-v1.0.int8.onnx", "voices-v1.0.bin")
        weight_sum = sum(weight for weight in self.voice_weights.values() if weight > 0)
        if weight_sum == 0:
            weight_sum = 1.0
        VOICEPACK = sum(
            kokoro.voices[voice] * (weight / weight_sum)
            for voice, weight in self.voice_weights.items() if weight > 0
        )

        def parse_text_file(filename):
            with open(filename, "r", encoding="utf-8") as f:
                lines = f.readlines()
            entries = []
            buffer = []
            current_voice = None
            for line in lines:
                line = line.strip()
                if line.startswith("[voice=") and line.endswith("]"):
                    if buffer:
                        entries.append(("voice", current_voice or "default", " ".join(buffer)))
                        buffer = []
                    current_voice = line[len("[voice="):-1]
                elif line.startswith("[pause=") and line.endswith("]"):
                    if buffer:
                        entries.append(("voice", current_voice or "default", " ".join(buffer)))
                        buffer = []
                    pause_duration = float(line[len("[pause="):-1])
                    entries.append(("pause", pause_duration))
                elif line:
                    buffer.append(line)
            if buffer:
                entries.append(("voice", current_voice or "default", " ".join(buffer)))
            return entries

        def split_sentences(text):
            sentences = re.split(r'(?<=[.!?])\s+', text.strip())
            return [s for s in sentences if s]

        entries = parse_text_file(self.input_file)
        print(f"DEBUG: [Prozess {self.process_id}] Eingabedatei geparst, {len(entries)} Einträge gefunden.")
        self.log_signal.emit(f"[Prozess {self.process_id}] Eingabedatei geparst, {len(entries)} Einträge gefunden.")

        # Zähle die Gesamtzahl der Sätze für den Fortschrittsbalken
        total_sentences = 0
        for entry_type, *args in entries:
            if entry_type == "voice":
                _, text = args
                sentences = split_sentences(text)
                total_sentences += len(sentences)
        print(f"DEBUG: [Prozess {self.process_id}] Gesamtzahl der Sätze: {total_sentences}")
        self.log_signal.emit(f"[Prozess {self.process_id}] Gesamtzahl der Sätze: {total_sentences}")

        sample_rate = 24000
        all_audio = []
        processed_sentences = 0

        for i, (entry_type, *args) in enumerate(entries):
            if self._stop:
                print(f"DEBUG: [Prozess {self.process_id}] Prozess abgebrochen.")
                self.log_signal.emit(f"[Prozess {self.process_id}] ❌ Prozess abgebrochen.")
                self.finished_signal.emit(self.process_id, self._was_canceled)
                return

            # Warte, wenn pausiert
            while self._paused and not self._stop:
                self.msleep(100)  # Kurze Schlafzeit, um CPU-Last zu minimieren

            if entry_type == "pause":
                custom_pause_duration = args[0]
                print(f"DEBUG: [Prozess {self.process_id}][{i+1}] Füge Pause von {custom_pause_duration} Sekunden ein.")
                self.log_signal.emit(f"[Prozess {self.process_id}][{i+1}] Füge benutzerdefinierte Pause von {custom_pause_duration} Sekunden ein.")
                silence = np.zeros(int(custom_pause_duration * sample_rate))
                all_audio.append(silence)
            else:
                voice, text = args
                if voice == "default" or voice == "custom_mix":
                    print(f"DEBUG: [Prozess {self.process_id}][{i+1}] Verarbeite mit gemischter Stimme (VOICEPACK).")
                    self.log_signal.emit(f"[Prozess {self.process_id}][{i+1}] Verarbeite mit gemischter Stimme (VOICEPACK)")
                    actual_voice = VOICEPACK
                else:
                    print(f"DEBUG: [Prozess {self.process_id}][{i+1}] Verarbeite mit Stimme '{voice}'.")
                    self.log_signal.emit(f"[Prozess {self.process_id}][{i+1}] Verarbeite mit Stimme '{voice}'")
                    try:
                        actual_voice = kokoro.voices[voice]
                    except KeyError:
                        print(f"DEBUG: [Prozess {self.process_id}] Stimme '{voice}' nicht gefunden, verwende VOICEPACK.")
                        self.log_signal.emit(f"[Prozess {self.process_id}] ⚠️ Stimme '{voice}' nicht gefunden, verwende VOICEPACK.")
                        actual_voice = VOICEPACK

                sentences = split_sentences(text)
                print(f"DEBUG: [Prozess {self.process_id}][{i+1}] Gefundene Sätze: {len(sentences)}")
                self.log_signal.emit(f"[Prozess {self.process_id}][{i+1}] Gefundene Sätze: {len(sentences)}")
                for sentence in sentences:
                    if self._stop:
                        print(f"DEBUG: [Prozess {self.process_id}] Prozess abgebrochen.")
                        self.log_signal.emit(f"[Prozess {self.process_id}] ❌ Prozess abgebrochen.")
                        self.finished_signal.emit(self.process_id, self._was_canceled)
                        return

                    # Warte, wenn pausiert
                    while self._paused and not self._stop:
                        self.msleep(100)

                    print(f"DEBUG: [Prozess {self.process_id}] Generiere Satz: \"{sentence[:40]}...\"")
                    self.log_signal.emit(f"[Prozess {self.process_id}] → Generiere Satz: \"{sentence[:40]}...\"")
                    samples, sr = kokoro.create(sentence, voice=actual_voice, speed=self.speed, lang="en-us")
                    print(f"DEBUG: [Prozess {self.process_id}] Abtastrate von kokoro.create: {sr}, Samples Länge: {len(samples)}")
                    self.log_signal.emit(f"[Prozess {self.process_id}] Abtastrate von kokoro.create: {sr}, Samples Länge: {len(samples)}")
                    if sr != sample_rate:
                        print(f"DEBUG: [Prozess {self.process_id}] Warnung: Abtastrate {sr} unterscheidet sich von {sample_rate}")
                        self.log_signal.emit(f"[Prozess {self.process_id}] ⚠️ Warnung: Abtastrate {sr} unterscheidet sich von {sample_rate}")
                    all_audio.append(samples)
                    if self.sentence_pause_duration > 0:
                        pause = np.zeros(int(self.sentence_pause_duration * sample_rate))
                        all_audio.append(pause)

                    processed_sentences += 1
                    progress = int((processed_sentences / total_sentences) * 100) if total_sentences > 0 else 0
                    self.progress_signal.emit(self.process_id, progress)

                    # Zeitangaben aktualisieren
                    elapsed_time = (time.time() - self.start_time) - self.total_pause_duration
                    if processed_sentences > 0:
                        avg_time_per_sentence = elapsed_time / processed_sentences
                        remaining_sentences = total_sentences - processed_sentences
                        estimated_remaining_time = remaining_sentences * avg_time_per_sentence
                        time_info = f"Zeit: {self.format_time(elapsed_time)} (ca. {self.format_time(estimated_remaining_time)} übrig)"
                    else:
                        time_info = f"Zeit: {self.format_time(elapsed_time)} (ca. --:--:-- übrig)"
                    self.time_signal.emit(self.process_id, time_info)

        if self._stop:
            print(f"DEBUG: [Prozess {self.process_id}] Prozess abgebrochen.")
            self.log_signal.emit(f"[Prozess {self.process_id}] ❌ Prozess abgebrochen.")
            self.finished_signal.emit(self.process_id, self._was_canceled)
            return

        print(f"DEBUG: [Prozess {self.process_id}] Gesamte Audiodaten: {len(all_audio)} Segmente")
        self.log_signal.emit(f"[Prozess {self.process_id}] Gesamte Audiodaten: {len(all_audio)} Segmente")
        if not all_audio:
            print(f"DEBUG: [Prozess {self.process_id}] Fehler: Keine Audiodaten generiert!")
            self.log_signal.emit(f"[Prozess {self.process_id}] ❌ Fehler: Keine Audiodaten generiert!")
            self.error_signal.emit(self.process_id, "Keine Audiodaten generiert")
            return

        final_audio = np.concatenate(all_audio)
        print(f"DEBUG: [Prozess {self.process_id}] Finales Audio Länge: {len(final_audio)} Samples")
        self.log_signal.emit(f"[Prozess {self.process_id}] Finales Audio Länge: {len(final_audio)} Samples")

        # Ausgabepfad validieren
        output_dir = os.path.dirname(self.output_file)
        if output_dir and not os.path.exists(output_dir):
            print(f"DEBUG: [Prozess {self.process_id}] Erstelle Verzeichnis: {output_dir}")
            self.log_signal.emit(f"[Prozess {self.process_id}] Erstelle Verzeichnis: {output_dir}")
            os.makedirs(output_dir, exist_ok=True)

        # Prüfen, ob der Pfad schreibbar ist
        if output_dir and not os.access(output_dir, os.W_OK):
            error_msg = f"[Prozess {self.process_id}] ❌ Fehler: Kein Schreibzugriff auf Verzeichnis {output_dir}"
            print(f"DEBUG: {error_msg}")
            self.log_signal.emit(error_msg)
            self.error_signal.emit(self.process_id, f"Kein Schreibzugriff auf Verzeichnis {output_dir}")
            return

        # Audiodatei speichern
        try:
            print(f"DEBUG: [Prozess {self.process_id}] Speichere Audiodatei: {self.output_file}")
            self.log_signal.emit(f"[Prozess {self.process_id}] Speichere Audiodatei: {self.output_file}")
            sf.write(self.output_file, final_audio, sample_rate)
            print(f"DEBUG: [Prozess {self.process_id}] ✅ Gespeichert: {self.output_file} mit Abtastrate {sample_rate}")
            self.log_signal.emit(f"[Prozess {self.process_id}] ✅ Gespeichert: {self.output_file} mit Abtastrate {sample_rate}")
        except (OSError, Exception) as e:
            error_msg = f"[Prozess {self.process_id}] ❌ Fehler beim Speichern der Audiodatei: {str(e)}"
            print(f"DEBUG: {error_msg}")
            self.log_signal.emit(error_msg)
            self.error_signal.emit(self.process_id, f"Fehler beim Speichern der Audiodatei: {str(e)}")
            return

    except Exception as e:
        error_msg = f"[Prozess {self.process_id}] ❌ Allgemeiner Fehler: {str(e)}"
        print(f"DEBUG: {error_msg}")
        self.log_signal.emit(error_msg)
        self.error_signal.emit(self.process_id, str(e))
    self.finished_signal.emit(self.process_id, self._was_canceled)

class MainWindow(QMainWindow):
def init(self):
super().init()
print("DEBUG: Initialisiere MainWindow...")
try:
self.setWindowTitle("Kokoro TTS GUI")
self.setGeometry(100, 100, 1200, 800)

        # Haupt-Widget und Layout
        main_widget = QWidget()
        self.setCentralWidget(main_widget)
        main_layout = QVBoxLayout()
        main_widget.setLayout(main_layout)

        # Scrollbares Eingabe-Widget
        scroll_widget = QWidget()
        scroll_layout = QVBoxLayout()
        scroll_widget.setLayout(scroll_layout)
        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(scroll_widget)

        # Eingabefelder für TTS-Parameter
        self.input_file_edit = QLineEdit()
        self.input_file_edit.setPlaceholderText("Wählen Sie eine Textdatei aus...")
        input_file_button = QPushButton("Durchsuchen...")
        input_file_button.clicked.connect(self.browse_input_file)

        self.output_file_edit = QLineEdit()
        self.output_file_edit.setPlaceholderText("Ausgabedatei (z.B. output.wav)")
        output_file_button = QPushButton("Durchsuchen...")
        output_file_button.clicked.connect(self.browse_output_file)

        self.pause_duration_spin = QDoubleSpinBox()
        self.pause_duration_spin.setRange(0.0, 10.0)
        self.pause_duration_spin.setValue(1.0)
        self.pause_duration_spin.setSingleStep(0.1)

        self.speed_spin = QDoubleSpinBox()
        self.speed_spin.setRange(0.1, 2.0)
        self.speed_spin.setValue(0.9)
        self.speed_spin.setSingleStep(0.1)

        # Stimmen laden
        print("DEBUG: Lade Kokoro-Modelldateien...")
        if not os.path.exists("kokoro-v1.0.int8.onnx") or not os.path.exists("voices-v1.0.bin"):
            raise FileNotFoundError("Kokoro-Modelldateien 'kokoro-v1.0.int8.onnx' oder 'voices-v1.0.bin' fehlen im Verzeichnis.")
        self.kokoro = Kokoro("kokoro-v1.0.int8.onnx", "voices-v1.0.bin")
        self.available_voices = sorted(self.kokoro.voices.keys())
        print(f"DEBUG: Verfügbare Stimmen: {self.available_voices}")

        # Voice-Gewichtungen mit Checkboxes
        self.voice_checkboxes = {}
        self.voice_spins = {}
        default_weights = {
            "am_adam": 0.0,
            "am_michael": 0.4,
            "am_echo": 0.2,
            "am_onyx": 0.4,
            "am_bella": 0.0,
            "am_sarah": 0.0,
            "br_charlie": 0.0,
            "br_nova": 0.0
        }
        default_enabled = {
            "am_adam": False,
            "am_michael": True,
            "am_echo": True,
            "am_onyx": True,
            "am_bella": False,
            "am_sarah": False,
            "br_charlie": False,
            "br_nova": False
        }
        for voice in self.available_voices:
            checkbox = QCheckBox(voice)
            checkbox.setChecked(default_enabled.get(voice, False))
            spin = QDoubleSpinBox()
            spin.setRange(0.0, 1.0)
            spin.setValue(default_weights.get(voice, 0.0))
            spin.setSingleStep(0.05)
            spin.setEnabled(checkbox.isChecked())
            checkbox.stateChanged.connect(lambda state, s=spin: s.setEnabled(state == Qt.Checked))
            self.voice_checkboxes[voice] = checkbox
            self.voice_spins[voice] = spin

        # Konfigurations-Buttons
        save_config_button = QPushButton("Konfiguration speichern")
        save_config_button.clicked.connect(self.save_configuration)
        load_config_button = QPushButton("Konfiguration laden")
        load_config_button.clicked.connect(self.load_configuration)

        # Button für Aufgabe hinzufügen
        print("DEBUG: Initialisiere Buttons...")
        self.add_task_button = QPushButton("Aufgabe hinzufügen")
        self.add_task_button.clicked.connect(self.add_task)

        # Prozesstabelle
        self.process_table = QTableWidget()
        self.process_table.setColumnCount(7)
        self.process_table.setHorizontalHeaderLabels(["Prozess-ID", "Eingabedatei", "Ausgabedatei", "Fortschritt", "Status", "Zeit", "Aktion"])
        self.process_table.setSelectionMode(QTableWidget.NoSelection)
        self.process_table.setEditTriggers(QTableWidget.NoEditTriggers)
        self.process_table.horizontalHeader().setStretchLastSection(True)

        # Layout zusammenstellen
        scroll_layout.addWidget(QLabel("Eingabe-Textdatei:"))
        input_layout = QHBoxLayout()
        input_layout.addWidget(self.input_file_edit)
        input_layout.addWidget(input_file_button)
        scroll_layout.addLayout(input_layout)

        scroll_layout.addWidget(QLabel("Ausgabe-Audiodatei:"))
        output_layout = QHBoxLayout()
        output_layout.addWidget(self.output_file_edit)
        output_layout.addWidget(output_file_button)
        scroll_layout.addLayout(output_layout)

        scroll_layout.addWidget(QLabel("Pausendauer nach Sätzen (Sekunden):"))
        scroll_layout.addWidget(self.pause_duration_spin)

        scroll_layout.addWidget(QLabel("Geschwindigkeit (speed):"))
        scroll_layout.addWidget(self.speed_spin)

        scroll_layout.addWidget(QLabel("Voice-Auswahl und Gewichtungen:"))
        for voice in self.available_voices:
            voice_layout = QHBoxLayout()
            voice_layout.addWidget(self.voice_checkboxes[voice])
            voice_layout.addWidget(self.voice_spins[voice])
            scroll_layout.addLayout(voice_layout)

        scroll_layout.addWidget(QLabel("Konfiguration:"))
        config_layout = QHBoxLayout()
        config_layout.addWidget(save_config_button)
        config_layout.addWidget(load_config_button)
        scroll_layout.addLayout(config_layout)

        scroll_layout.addStretch()

        main_layout.addWidget(scroll_area)
        main_layout.addWidget(self.add_task_button)
        main_layout.addWidget(QLabel("Prozesse:"))
        main_layout.addWidget(self.process_table)

        # Aufgabenliste und Threads
        self.tasks = []  # Speichert Task-Details für Neustart
        self.threads = {}
        self.process_counter = 0
        self.max_threads = 2  # Stabil mit 4 Threads
        self.task_queue = []
        self.pending_cleanup = set()  # Verfolgt Threads, die auf Bereinigung warten

        print("DEBUG: MainWindow-Initialisierung abgeschlossen.")
    except Exception as e:
        print(f"ERROR: Fehler bei der Initialisierung der GUI: {str(e)}")
        raise

def browse_input_file(self):
    file_name, _ = QFileDialog.getOpenFileName(self, "Textdatei auswählen", "", "Textdateien (*.txt)")
    if file_name:
        self.input_file_edit.setText(file_name)

def browse_output_file(self):
    file_name, _ = QFileDialog.getSaveFileName(self, "Ausgabedatei auswählen", "", "Audiodateien (*.wav)")
    if file_name:
        self.output_file_edit.setText(file_name)

def save_configuration(self):
    print("DEBUG: Speichere Konfiguration...")
    file_name, _ = QFileDialog.getSaveFileName(self, "Konfiguration speichern", "configs/", "JSON-Dateien (*.json)")
    if file_name:
        if not file_name.endswith(".json"):
            file_name += ".json"
        config = {
            "speed": self.speed_spin.value(),
            "pause_duration": self.pause_duration_spin.value(),
            "voice_weights": {voice: self.voice_spins[voice].value() for voice in self.available_voices},
            "voice_enabled": {voice: self.voice_checkboxes[voice].isChecked() for voice in self.available_voices}
        }
        os.makedirs(os.path.dirname(file_name), exist_ok=True)
        try:
            with open(file_name, "w", encoding="utf-8") as f:
                json.dump(config, f, indent=4)
            print(f"DEBUG: Konfiguration gespeichert unter: {file_name}")
        except Exception as e:
            QMessageBox.warning(self, "Fehler", f"Konnte Konfiguration nicht speichern: {str(e)}")

def load_configuration(self):
    print("DEBUG: Lade Konfiguration...")
    file_name, _ = QFileDialog.getOpenFileName(self, "Konfiguration laden", "configs/", "JSON-Dateien (*.json)")
    if file_name:
        try:
            with open(file_name, "r", encoding="utf-8") as f:
                config = json.load(f)
            self.speed_spin.setValue(config.get("speed", 0.9))
            self.pause_duration_spin.setValue(config.get("pause_duration", 1.0))
            for voice in self.available_voices:
                weight = config.get("voice_weights", {}).get(voice, 0.0)
                enabled = config.get("voice_enabled", {}).get(voice, False)
                self.voice_spins[voice].setValue(weight)
                self.voice_checkboxes[voice].setChecked(enabled)
                self.voice_spins[voice].setEnabled(enabled)
            print(f"DEBUG: Konfiguration geladen von: {file_name}")
        except Exception as e:
            QMessageBox.warning(self, "Fehler", f"Konnte Konfiguration nicht laden: {str(e)}")

def add_task(self):
    print("DEBUG: Aufgabe hinzufügen...")
    input_file = self.input_file_edit.text()
    output_file = self.output_file_edit.text()
    sentence_pause_duration = self.pause_duration_spin.value()
    speed = self.speed_spin.value()
    voice_weights = {
        voice: self.voice_spins[voice].value() if self.voice_checkboxes[voice].isChecked() else 0.0
        for voice in self.available_voices
    }

    if not input_file or not os.path.exists(input_file):
        QMessageBox.warning(self, "Fehler", "Bitte eine gültige Eingabedatei auswählen.")
        return
    if not output_file:
        QMessageBox.warning(self, "Fehler", "Bitte einen Ausgabedateinamen angeben.")
        return
    if not output_file.lower().endswith('.wav'):
        QMessageBox.warning(self, "Fehler", "Die Ausgabedatei muss eine .wav-Datei sein.")
        return
    if all(weight == 0.0 for weight in voice_weights.values()):
        QMessageBox.warning(self, "Fehler", "Bitte mindestens eine Stimme aktivieren und eine Gewichtung > 0 setzen.")
        return

    self.process_counter += 1
    task = {
        "process_id": self.process_counter,
        "input_file": input_file,
        "output_file": output_file,
        "sentence_pause_duration": sentence_pause_duration,
        "speed": speed,
        "voice_weights": voice_weights
    }
    self.tasks.append(task)  # Speichere Task für möglichen Neustart
    self.task_queue.append(task)
    self.add_task_to_table(task)
    self.input_file_edit.clear()
    self.output_file_edit.clear()
    self.start_queued_tasks()

def add_task_to_table(self, task):
    row = self.process_table.rowCount()
    self.process_table.insertRow(row)
    self.process_table.setItem(row, 0, QTableWidgetItem(str(task["process_id"])))
    self.process_table.setItem(row, 1, QTableWidgetItem(task["input_file"]))
    self.process_table.setItem(row, 2, QTableWidgetItem(task["output_file"]))
    progress_bar = QProgressBar()
    progress_bar.setValue(0)
    self.process_table.setCellWidget(row, 3, progress_bar)
    self.process_table.setItem(row, 4, QTableWidgetItem("Wartet"))
    self.process_table.setItem(row, 5, QTableWidgetItem("Zeit: --:--:-- (ca. --:--:-- übrig)"))

    # Aktion-Widget mit Abbrechen-, Neu starten- und Pausieren-Button
    action_widget = QWidget()
    action_layout = QHBoxLayout()
    action_layout.setContentsMargins(0, 0, 0, 0)
    action_widget.setLayout(action_layout)

    cancel_button = QPushButton("Abbrechen")
    cancel_button.clicked.connect(lambda: self.cancel_task(task["process_id"]))
    cancel_button.setEnabled(True)
    action_layout.addWidget(cancel_button)

    restart_button = QPushButton("Neu starten")
    restart_button.clicked.connect(lambda: self.restart_task(task["process_id"]))
    restart_button.setEnabled(False)
    action_layout.addWidget(restart_button)

    pause_button = QPushButton("Pausieren")
    pause_button.clicked.connect(lambda: self.pause_task(task["process_id"]))
    pause_button.setEnabled(True)
    action_layout.addWidget(pause_button)

    self.process_table.setCellWidget(row, 6, action_widget)
    self.process_table.resizeColumnsToContents()

def start_queued_tasks(self):
    print(f"DEBUG: Starte Warteschlangenaufgaben, {len(self.task_queue)} in der Warteschlange, {len(self.threads)} laufende Threads...")
    if self.pending_cleanup:
        print(f"DEBUG: Warte auf {len(self.pending_cleanup)} ausstehende Thread-Bereinigungen, verschiebe Start...")
        QTimer.singleShot(100, self.start_queued_tasks)
        return
    while self.task_queue and len(self.threads) < self.max_threads:
        task = self.task_queue.pop(0)
        thread = TTSThread(
            task["process_id"],
            task["input_file"],
            task["output_file"],
            task["sentence_pause_duration"],
            task["speed"],
            task["voice_weights"]
        )
        thread.log_signal.connect(self.update_log)
        thread.progress_signal.connect(self.update_progress)
        thread.time_signal.connect(self.update_time)
        thread.status_signal.connect(self.update_task_status)
        thread.finished_signal.connect(self.on_tts_finished)
        thread.error_signal.connect(self.on_tts_error)
        self.threads[task["process_id"]] = thread
        self.update_task_status(task["process_id"], "Läuft")
        print(f"DEBUG: Starte Thread für Prozess {task['process_id']}...")
        thread.start()

def update_log(self, message):
    row = self.process_table.rowCount() - 1
    self.process_table.scrollToBottom()

def update_progress(self, process_id, progress):
    for row in range(self.process_table.rowCount()):
        if self.process_table.item(row, 0).text() == str(process_id):
            progress_bar = self.process_table.cellWidget(row, 3)
            progress_bar.setValue(progress)
            break

def update_time(self, process_id, time_info):
    for row in range(self.process_table.rowCount()):
        if self.process_table.item(row, 0).text() == str(process_id):
            self.process_table.setItem(row, 5, QTableWidgetItem(time_info))
            break

def update_task_status(self, process_id, status):
    for row in range(self.process_table.rowCount()):
        if self.process_table.item(row, 0).text() == str(process_id):
            self.process_table.setItem(row, 4, QTableWidgetItem(status))
            action_widget = self.process_table.cellWidget(row, 6)
            cancel_button = action_widget.layout().itemAt(0).widget()
            restart_button = action_widget.layout().itemAt(1).widget()
            pause_button = action_widget.layout().itemAt(2).widget()

            if status in ["Läuft", "Pausiert"]:
                cancel_button.setEnabled(True)
                restart_button.setEnabled(False)
                pause_button.setEnabled(True)
                pause_button.setText("Fortführen" if status == "Pausiert" else "Pausieren")
            elif status == "Abbruch läuft...":
                cancel_button.setEnabled(True)
                restart_button.setEnabled(False)
                pause_button.setEnabled(False)
            else:  # Abgeschlossen, Abgebrochen, Fehler
                cancel_button.setEnabled(False)
                restart_button.setEnabled(True)
                pause_button.setEnabled(False)
                pause_button.setText("Pausieren")
                # Zeitangabe einfrieren
                current_time = self.process_table.item(row, 5).text()
                if "übrig" in current_time:
                    elapsed = current_time.split(" (")[0]
                    self.process_table.setItem(row, 5, QTableWidgetItem(elapsed))
            break

def cancel_task(self, process_id):
    print(f"DEBUG: Breche Prozess {process_id} ab...")
    if process_id in self.threads:
        thread = self.threads[process_id]
        print(f"DEBUG: Sende Stop-Signal an Thread für Prozess {process_id}...")
        thread.stop()
        self.update_task_status(process_id, "Abbruch läuft...")
        self.pending_cleanup.add(process_id)
    else:
        print(f"DEBUG: Warnung: Thread für Prozess {process_id} nicht in Threads-Dictionary gefunden.")
        self.update_task_status(process_id, "Abgebrochen")

def pause_task(self, process_id):
    print(f"DEBUG: Pausiere/Fortführe Prozess {process_id}...")
    if process_id in self.threads:
        thread = self.threads[process_id]
        thread.pause()
    else:
        print(f"DEBUG: Warnung: Thread für Prozess {process_id} nicht in Threads-Dictionary gefunden.")

def restart_task(self, process_id):
    print(f"DEBUG: Starte Prozess {process_id} neu...")
    for task in self.tasks:
        if task["process_id"] == process_id:
            self.process_counter += 1
            new_task = {
                "process_id": self.process_counter,
                "input_file": task["input_file"],
                "output_file": task["output_file"],
                "sentence_pause_duration": task["sentence_pause_duration"],
                "speed": task["speed"],
                "voice_weights": task["voice_weights"]
            }
            self.tasks.append(new_task)
            self.task_queue.append(new_task)
            self.add_task_to_table(new_task)
            self.start_queued_tasks()
            print(f"DEBUG: Neue Aufgabe mit Prozess-ID {self.process_counter} hinzugefügt.")
            return
    print(f"DEBUG: Warnung: Task mit Prozess-ID {process_id} nicht in tasks-Liste gefunden.")
    QMessageBox.warning(self, "Fehler", f"Prozess {process_id} konnte nicht neu gestartet werden: Aufgabe nicht gefunden.")

def on_tts_finished(self, process_id, was_canceled):
    print(f"DEBUG: Prozess {process_id} abgeschlossen, abgebrochen={was_canceled}.")
    if process_id in self.threads:
        thread = self.threads[process_id]
        print(f"DEBUG: Thread-Status für Prozess {process_id}: isRunning={thread.isRunning()}, isFinished={thread.isFinished()}")
        if thread.isFinished():
            status = "Abgebrochen" if was_canceled else "Abgeschlossen"
            self.update_task_status(process_id, status)
            print(f"DEBUG: Entferne Thread für Prozess {process_id} aus Threads-Dictionary...")
            del self.threads[process_id]
            if process_id in self.pending_cleanup:
                self.pending_cleanup.remove(process_id)
            self.start_queued_tasks()
        else:
            print(f"DEBUG: Thread für Prozess {process_id} noch nicht beendet, verzögere Bereinigung...")
            QTimer.singleShot(100, lambda: self.on_tts_finished(process_id, was_canceled))
    else:
        print(f"DEBUG: Warnung: Thread für Prozess {process_id} nicht in Threads-Dictionary gefunden.")
        if process_id in self.pending_cleanup:
            self.pending_cleanup.remove(process_id)

def on_tts_error(self, process_id, error):
    print(f"DEBUG: Fehler in Prozess {process_id}: {error}")
    if process_id in self.threads:
        thread = self.threads[process_id]
        print(f"DEBUG: Thread-Status für Prozess {process_id}: isRunning={thread.isRunning()}, isFinished={thread.isFinished()}")
        if thread.isFinished():
            self.update_task_status(process_id, f"Fehler: {error}")
            print(f"DEBUG: Entferne Thread für Prozess {process_id} aus Threads-Dictionary...")
            del self.threads[process_id]
            if process_id in self.pending_cleanup:
                self.pending_cleanup.remove(process_id)
            self.start_queued_tasks()
        else:
            print(f"DEBUG: Thread für Prozess {process_id} noch nicht beendet, verzögere Bereinigung...")
            QTimer.singleShot(100, lambda: self.on_tts_error(process_id, error))
    else:
        print(f"DEBUG: Warnung: Thread für Prozess {process_id} nicht in Threads-Dictionary gefunden.")
        if process_id in self.pending_cleanup:
            self.pending_cleanup.remove(process_id)

if name == 'main':
print("DEBUG: Starte QApplication...")
try:
app = QApplication(sys.argv)
print("DEBUG: Erstelle MainWindow...")
window = MainWindow()
print("DEBUG: Zeige GUI an...")
window.show()
print("DEBUG: Starte Event-Loop...")
sys.exit(app.exec_())
except Exception as e:
print(f"ERROR: Fehler beim Starten der GUI: {str(e)}")

[Patrick-Ric]

This python Code is running on CPU on my Linux (Manjaro) PC without GPU.