Merge pull request #173 from k0sm0naft/refactor/tts-backend-interface

refactor: introduce TTS backend abstraction

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: [jborza, jeremiahsb, mohangk]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.gitignore

@@ -38,3 +38,4 @@ dist/
 .old/
 test_assets/
 dev_notes/
+.claude/

abogen/VERSION

@@ -1 +1 @@
-1.3.0
+1.3.1

abogen/book_parser.py

@@ -915,7 +915,11 @@ class EpubParser(BaseBookParser):
 
             if slice_html.strip():
                 slice_soup = BeautifulSoup(slice_html, "html.parser")
-                for tag in slice_soup.find_all(["p", "div"]):
+
+                # Add line breaks after block-level elements to ensure pauses in speech
+                for tag in slice_soup.find_all(
+                    ["p", "div", "h1", "h2", "h3", "h4", "h5", "h6", "li", "blockquote"]
+                ):
                     tag.append("\n\n")
 
                 for ol in slice_soup.find_all("ol"):

abogen/conversion.py

@@ -1,16 +0,0 @@
-"""Backwards-compatible re-export of conversion module.
-
-The PyQt-based implementation lives in abogen.pyqt.conversion.
-The web-based implementation is in abogen.webui.conversion_runner.
-"""
-
-from __future__ import annotations
-
-# Re-export PyQt conversion classes for backwards compatibility
-from abogen.pyqt.conversion import (  # noqa: F401
-    ConversionThread,
-    VoicePreviewThread,
-    PlayAudioThread,
-)
-
-__all__ = ["ConversionThread", "VoicePreviewThread", "PlayAudioThread"]

abogen/pyqt/conversion.py

@@ -42,6 +42,10 @@ from abogen.subtitle_utils import (
     get_sample_voice_text,
     sanitize_name_for_os,
     _CHAPTER_MARKER_SEARCH_PATTERN,
+    _VOICE_MARKER_PATTERN,
+    _VOICE_MARKER_SEARCH_PATTERN,
+    split_text_by_voice_markers,
+    validate_voice_name,
 )
 
 class CountdownDialog(QDialog):
@@ -296,6 +300,31 @@ class ConversionThread(QThread):
         self.use_spacy_segmentation = True  # Default, will be overridden from GUI
         # Set split pattern based on language and subtitle mode
         self.split_pattern = self._get_split_pattern(lang_code, subtitle_mode)
+        self.voice_cache = {}  # Cache for loaded voices
+
+    def load_voice_cached(self, voice_name, tts):
+        """Load voice with caching to avoid reloading same voice.
+
+        Args:
+            voice_name: Voice name or formula string
+            tts: TTS pipeline instance
+
+        Returns:
+            Loaded voice tensor or voice name string
+        """
+        # Check cache first
+        if voice_name in self.voice_cache:
+            return self.voice_cache[voice_name]
+
+        # Load voice
+        if "*" in voice_name:
+            loaded_voice = get_new_voice(tts, voice_name, self.use_gpu)
+        else:
+            loaded_voice = voice_name
+
+        # Cache it
+        self.voice_cache[voice_name] = loaded_voice
+        return loaded_voice
 
     def _stream_audio_in_chunks(
         self, segments, process_func, progress_prefix="Processing"
@@ -524,6 +553,26 @@ class ConversionThread(QThread):
             # Clean up text using utility function
             text = clean_text(text)
 
+            # Apply word substitutions if enabled
+            if getattr(self, "word_substitutions_enabled", False):
+                from abogen.word_substitution import apply_word_substitutions
+
+                self.log_updated.emit("Applying word substitutions...")
+
+                substitutions_list = getattr(self, "word_substitutions_list", "")
+                case_sensitive = getattr(self, "case_sensitive_substitutions", False)
+                replace_caps = getattr(self, "replace_all_caps", False)
+                replace_nums = getattr(self, "replace_numerals", False)
+                fix_punct = getattr(self, "fix_nonstandard_punctuation", False)
+
+                text = apply_word_substitutions(
+                    text,
+                    substitutions_list,
+                    case_sensitive,
+                    replace_caps,
+                    replace_nums,
+                    fix_punct,
+                )
 
             # --- Chapter splitting logic ---
             # Use pre-compiled pattern for better performance
@@ -550,6 +599,42 @@ class ConversionThread(QThread):
                 chapters = [("text", text)]
             total_chapters = len(chapters)
 
+            # --- Voice marker splitting logic ---
+            # Split each chapter by voice markers, preserving voice state across chapters
+            chapters_with_voices = []
+            current_voice = self.voice  # Start with default voice
+            total_valid_markers = 0
+            total_invalid_markers = 0
+
+            for chapter_name, chapter_text in chapters:
+                # Use current_voice as the starting voice for this chapter
+                voice_segments, last_voice, valid_count, invalid_count = split_text_by_voice_markers(chapter_text, current_voice)
+                chapters_with_voices.append((chapter_name, voice_segments))
+
+                # Update current_voice so next chapter continues with this voice
+                current_voice = last_voice
+
+                # Track total valid/invalid markers
+                total_valid_markers += valid_count
+                total_invalid_markers += invalid_count
+
+            # Log voice marker information with accurate counts
+            total_markers = total_valid_markers + total_invalid_markers
+            if total_markers > 0:
+                if total_invalid_markers == 0:
+                    # All markers were valid
+                    self.log_updated.emit(
+                        (f"\nDetected {total_markers} voice marker(s) - all valid", "grey")
+                    )
+                else:
+                    # Some markers were invalid
+                    self.log_updated.emit(
+                        (f"\nDetected {total_markers} voice marker(s) - {total_valid_markers} valid, {total_invalid_markers} invalid (using previous voice)", "orange")
+                    )
+
+            # Replace chapters with the new structure
+            chapters = chapters_with_voices
+
             # For text files with chapters, prompt user for options if not already set
             is_txt_file = not self.is_direct_text and (
                 self.file_name.lower().endswith(".txt")
@@ -842,7 +927,7 @@ class ConversionThread(QThread):
                 ]
                 srt_index = 1  # SRT numbering fix for chapter-only mode
             # Instead of processing the whole text, process by chapter
-            for chapter_idx, (chapter_name, chapter_text) in enumerate(chapters, 1):
+            for chapter_idx, (chapter_name, voice_segments) in enumerate(chapters, 1):
                 chapter_out_path = None
                 chapter_out_file = None
                 chapter_ffmpeg_proc = None
@@ -862,11 +947,6 @@ class ConversionThread(QThread):
                 if merge_chapters_at_end:
                     chapter_time["start"] = current_time
 
-                # Check if the voice is a formula and load it if necessary
-                if "*" in self.voice:
-                    loaded_voice = get_new_voice(tts, self.voice, self.use_gpu)
-                else:
-                    loaded_voice = self.voice
                 # Prepare per-chapter output file if needed
                 if save_chapters_separately and total_chapters > 1:
                     # First pass: keep alphanumeric, spaces, hyphens, and underscores
@@ -986,286 +1066,302 @@ class ConversionThread(QThread):
                     chapter_subtitle_path = None
                     chapter_subtitle_file = None
 
-                # Determine if spaCy segmentation should be used for PRE-TTS segmentation
-                # Only non-English languages use spaCy for pre-segmentation
-                # English uses spaCy only for subtitle generation (post-TTS)
-                # spaCy is disabled when subtitle mode is "Disabled" or "Line"
-                # spaCy is also disabled when input is a subtitle file
-                is_subtitle_input = (
-                    not self.is_direct_text
-                    and self.file_name
-                    and os.path.splitext(self.file_name)[1].lower()
-                    in [".srt", ".ass", ".vtt"]
-                )
-                use_spacy = (
-                    getattr(self, "use_spacy_segmentation", False)
-                    and self.subtitle_mode not in ["Disabled", "Line"]
-                    and not is_subtitle_input
-                )
-                spacy_sentences = None
-                active_split_pattern = self.split_pattern
-                spacing_pattern = r"\s*" if self.lang_code in ["z", "j"] else r"\s+"
 
-                # Pre-load spaCy model for English if it will be needed for subtitle generation
+                # Process each voice segment within the chapter
-                if (
+                for segment_idx, (voice_name, segment_text) in enumerate(voice_segments):
-                    use_spacy
+                    # Load voice for this segment (with caching)
-                    and self.lang_code in ["a", "b"]
+                    try:
-                    and self.subtitle_mode in ["Sentence", "Sentence + Comma"]
+                        loaded_voice = self.load_voice_cached(voice_name, tts)
-                ):
+                        if segment_idx > 0:
-                    from abogen.spacy_utils import get_spacy_model
+                            voice_display = voice_name if len(voice_name) < 50 else voice_name[:47] + "..."
-
+                            self.log_updated.emit((f"  → Voice: {voice_display}", "grey"))
-                    nlp = get_spacy_model(
+                    except Exception:
-                        self.lang_code,
-                        log_callback=lambda msg: self.log_updated.emit(msg),
-                    )
-                    if nlp:
                         self.log_updated.emit(
-                            (
+                            (f"⚠ Voice loading error for '{voice_name}', continuing with previous", "orange")
-                                "\nUsing spaCy for sentence segmentation (only for subtitles)...",
-                                "grey",
-                            )
                         )
+                        if segment_idx == 0:
+                            loaded_voice = self.load_voice_cached(self.voice, tts)
 
-                if use_spacy and self.lang_code not in ["a", "b"]:
+                    # Determine if spaCy segmentation should be used for PRE-TTS segmentation
-                    # Non-English: use spaCy for pre-TTS segmentation
+                    # Only non-English languages use spaCy for pre-segmentation
-                    self.log_updated.emit(
+                    # English uses spaCy only for subtitle generation (post-TTS)
-                        ("\nUsing spaCy for sentence segmentation (pre-TTS)...", "grey")
+                    # spaCy is disabled when subtitle mode is "Disabled" or "Line"
+                    # spaCy is also disabled when input is a subtitle file
+                    is_subtitle_input = (
+                        not self.is_direct_text
+                        and self.file_name
+                        and os.path.splitext(self.file_name)[1].lower()
+                        in [".srt", ".ass", ".vtt"]
                     )
-                    from abogen.spacy_utils import segment_sentences
+                    use_spacy = (
-
+                        getattr(self, "use_spacy_segmentation", False)
-                    spacy_sentences = segment_sentences(
+                        and self.subtitle_mode not in ["Disabled", "Line"]
-                        chapter_text,
+                        and not is_subtitle_input
-                        self.lang_code,
-                        log_callback=lambda msg: self.log_updated.emit(msg),
                     )
-                    if spacy_sentences:
+                    spacy_sentences = None
-                        self.log_updated.emit(
+                    active_split_pattern = self.split_pattern
-                            (
+                    spacing_pattern = r"\s*" if self.lang_code in ["z", "j"] else r"\s+"
-                                f"\nspaCy: Text segmented into {len(spacy_sentences)} sentences...",
-                                "grey",
-                            )
-                        )
-                        # For Sentence + Comma mode, still split on commas within spaCy sentences
-                        if self.subtitle_mode == "Sentence + Comma":
-                            active_split_pattern = r"(?<=[{}]){}|\n+".format(
-                                self.PUNCTUATION_COMMAS, spacing_pattern
-                            )
-                        else:
-                            active_split_pattern = (
-                                "\n"  # Use newline splitting for Sentence mode
-                            )
-                    else:
-                        self.log_updated.emit(
-                            ("\nspaCy: Fallback to default segmentation...", "grey")
-                        )
 
-                # Process text - either as spaCy sentences or as single text
+                    # Pre-load spaCy model for English if it will be needed for subtitle generation
-                text_segments = spacy_sentences if spacy_sentences else [chapter_text]
+                    if (
-
+                        use_spacy
-                # Print active split pattern used by the TTS engine once for this batch
+                        and self.lang_code in ["a", "b"]
-                try:
+                        and self.subtitle_mode in ["Sentence", "Sentence + Comma"]
-                    print(f"Using split pattern: {active_split_pattern!r}")
-                except Exception:
-                    # Print must never break processing
-                    print("Using split pattern: (unprintable)")
-
-                for text_segment in text_segments:
-                    for result in tts(
-                        text_segment,
-                        voice=loaded_voice,
-                        speed=self.speed,
-                        split_pattern=active_split_pattern,
                     ):
-                        # Print the result for debugging
+                        from abogen.spacy_utils import get_spacy_model
-                        # print(f"Result: {result}")
+
-                        if self.cancel_requested:
+                        nlp = get_spacy_model(
-                            if chapter_out_file:
+                            self.lang_code,
-                                chapter_out_file.close()
+                            log_callback=lambda msg: self.log_updated.emit(msg),
-                            if merged_out_file:
-                                merged_out_file.close()
-                            self.conversion_finished.emit("Cancelled", None)
-                            return
-                        current_segment += 1
-                        grapheme_len = len(result.graphemes)
-                        self.processed_char_count += grapheme_len
-                        # Log progress with both character counts and the graphemes content
-                        self.log_updated.emit(
-                            f"\n{self.processed_char_count:,}/{self.total_char_count:,}: {result.graphemes}"
                         )
+                        if nlp:
+                            self.log_updated.emit(
+                                (
+                                    "\nUsing spaCy for sentence segmentation (only for subtitles)...",
+                                    "grey",
+                                )
+                            )
 
-                        chunk_dur = len(result.audio) / rate
+                    if use_spacy and self.lang_code not in ["a", "b"]:
-                        chunk_start = current_time
+                        # Non-English: use spaCy for pre-TTS segmentation
-                        # Write audio directly to merged file ONLY if merging
+                        self.log_updated.emit(
-                        if merge_chapters_at_end and merged_out_file:
+                            ("\nUsing spaCy for sentence segmentation (pre-TTS)...", "grey")
-                            merged_out_file.write(result.audio)
+                        )
-                        elif merge_chapters_at_end and ffmpeg_proc:
+                        from abogen.spacy_utils import segment_sentences
-                            if hasattr(result.audio, "numpy"):
+
-                                audio_bytes = (
+                        spacy_sentences = segment_sentences(
-                                    result.audio.numpy().astype("float32").tobytes()
+                            segment_text,
+                            self.lang_code,
+                            log_callback=lambda msg: self.log_updated.emit(msg),
+                        )
+                        if spacy_sentences:
+                            self.log_updated.emit(
+                                (
+                                    f"\nspaCy: Text segmented into {len(spacy_sentences)} sentences...",
+                                    "grey",
+                                )
+                            )
+                            # For Sentence + Comma mode, still split on commas within spaCy sentences
+                            if self.subtitle_mode == "Sentence + Comma":
+                                active_split_pattern = r"(?<=[{}]){}|\n+".format(
+                                    self.PUNCTUATION_COMMAS, spacing_pattern
                                 )
                             else:
-                                audio_bytes = result.audio.astype("float32").tobytes()
+                                active_split_pattern = (
-                            ffmpeg_proc.stdin.write(audio_bytes)
+                                    "\n"  # Use newline splitting for Sentence mode
-                        if chapter_out_file:
-                            chapter_out_file.write(result.audio)
-                        elif chapter_ffmpeg_proc:
-                            if hasattr(result.audio, "numpy"):
-                                audio_bytes = (
-                                    result.audio.numpy().astype("float32").tobytes()
                                 )
-                            else:
+                        else:
-                                audio_bytes = result.audio.astype("float32").tobytes()
+                            self.log_updated.emit(
-                            chapter_ffmpeg_proc.stdin.write(audio_bytes)
+                                ("\nspaCy: Fallback to default segmentation...", "grey")
-                        # Subtitle logic
+                            )
-                        if self.subtitle_mode != "Disabled":
-                            tokens_list = getattr(result, "tokens", [])
 
-                            # Fallback for languages without token support (non-English)
+                    # Process text - either as spaCy sentences or as single text
-                            # Create a single token representing the entire segment duration
+                    text_segments = spacy_sentences if spacy_sentences else [segment_text]
-                            if not tokens_list and result.graphemes:
 
-                                class FakeToken:
+                    # Print active split pattern used by the TTS engine once for this batch
-                                    def __init__(self, text, start, end):
+                    try:
-                                        self.text = text
+                        print(f"Using split pattern: {active_split_pattern!r}")
-                                        self.start_ts = start
+                    except Exception:
-                                        self.end_ts = end
+                        # Print must never break processing
-                                        self.whitespace = ""
+                        print("Using split pattern: (unprintable)")
 
-                                tokens_list = [
+                    for text_segment in text_segments:
-                                    FakeToken(result.graphemes, 0, chunk_dur)
+                        for result in tts(
-                                ]
+                            text_segment,
+                            voice=loaded_voice,
+                            speed=self.speed,
+                            split_pattern=active_split_pattern,
+                        ):
+                            # Print the result for debugging
+                            # print(f"Result: {result}")
+                            if self.cancel_requested:
+                                if chapter_out_file:
+                                    chapter_out_file.close()
+                                if merged_out_file:
+                                    merged_out_file.close()
+                                self.conversion_finished.emit("Cancelled", None)
+                                return
+                            current_segment += 1
+                            grapheme_len = len(result.graphemes)
+                            self.processed_char_count += grapheme_len
+                            # Log progress with both character counts and the graphemes content
+                            self.log_updated.emit(
+                                f"\n{self.processed_char_count:,}/{self.total_char_count:,}: {result.graphemes}"
+                            )
 
-                            tokens_with_timestamps = []
+                            chunk_dur = len(result.audio) / rate
-                            chapter_tokens_with_timestamps = []
+                            chunk_start = current_time
+                            # Write audio directly to merged file ONLY if merging
+                            if merge_chapters_at_end and merged_out_file:
+                                merged_out_file.write(result.audio)
+                            elif merge_chapters_at_end and ffmpeg_proc:
+                                if hasattr(result.audio, "numpy"):
+                                    audio_bytes = (
+                                        result.audio.numpy().astype("float32").tobytes()
+                                    )
+                                else:
+                                    audio_bytes = result.audio.astype("float32").tobytes()
+                                ffmpeg_proc.stdin.write(audio_bytes)
+                            if chapter_out_file:
+                                chapter_out_file.write(result.audio)
+                            elif chapter_ffmpeg_proc:
+                                if hasattr(result.audio, "numpy"):
+                                    audio_bytes = (
+                                        result.audio.numpy().astype("float32").tobytes()
+                                    )
+                                else:
+                                    audio_bytes = result.audio.astype("float32").tobytes()
+                                chapter_ffmpeg_proc.stdin.write(audio_bytes)
+                            # Subtitle logic
+                            if self.subtitle_mode != "Disabled":
+                                tokens_list = getattr(result, "tokens", [])
 
-                            # Process every token, regardless of text or timestamps
+                                # Fallback for languages without token support (non-English)
-                            for tok in tokens_list:
+                                # Create a single token representing the entire segment duration
-                                tokens_with_timestamps.append(
+                                if not tokens_list and result.graphemes:
-                                    {
+
-                                        "start": chunk_start + (tok.start_ts or 0),
+                                    class FakeToken:
-                                        "end": chunk_start + (tok.end_ts or 0),
+                                        def __init__(self, text, start, end):
-                                        "text": tok.text,
+                                            self.text = text
-                                        "whitespace": tok.whitespace,
+                                            self.start_ts = start
-                                    }
+                                            self.end_ts = end
-                                )
+                                            self.whitespace = ""
-                                if chapter_out_file or chapter_ffmpeg_proc:
+
-                                    chapter_tokens_with_timestamps.append(
+                                    tokens_list = [
+                                        FakeToken(result.graphemes, 0, chunk_dur)
+                                    ]
+
+                                tokens_with_timestamps = []
+                                chapter_tokens_with_timestamps = []
+
+                                # Process every token, regardless of text or timestamps
+                                for tok in tokens_list:
+                                    tokens_with_timestamps.append(
                                         {
-                                            "start": chapter_current_time
+                                            "start": chunk_start + (tok.start_ts or 0),
-                                            + (tok.start_ts or 0),
+                                            "end": chunk_start + (tok.end_ts or 0),
-                                            "end": chapter_current_time
-                                            + (tok.end_ts or 0),
                                             "text": tok.text,
                                             "whitespace": tok.whitespace,
                                         }
                                     )
-                            # Process tokens according to subtitle mode
+                                    if chapter_out_file or chapter_ffmpeg_proc:
-                            # Global subtitle processing ONLY if merging
+                                        chapter_tokens_with_timestamps.append(
+                                            {
+                                                "start": chapter_current_time
+                                                + (tok.start_ts or 0),
+                                                "end": chapter_current_time
+                                                + (tok.end_ts or 0),
+                                                "text": tok.text,
+                                                "whitespace": tok.whitespace,
+                                            }
+                                        )
+                                # Process tokens according to subtitle mode
+                                # Global subtitle processing ONLY if merging
+                                if merge_chapters_at_end:
+                                    # Incremental subtitle writing for merged output
+                                    new_entries = []
+                                    self._process_subtitle_tokens(
+                                        tokens_with_timestamps,
+                                        new_entries,
+                                        self.max_subtitle_words,
+                                        fallback_end_time=chunk_start + chunk_dur,
+                                    )
+                                    if merged_subtitle_file:
+                                        subtitle_format = getattr(
+                                            self, "subtitle_format", "srt"
+                                        )
+                                        if "ass" in subtitle_format:
+                                            for start, end, text in new_entries:
+                                                start_time = self._ass_time(start)
+                                                end_time = self._ass_time(end)
+                                                # Use karaoke effect for highlighting mode
+                                                effect = (
+                                                    "karaoke"
+                                                    if self.subtitle_mode
+                                                    == "Sentence + Highlighting"
+                                                    else ""
+                                                )
+                                                merged_subtitle_file.write(
+                                                    f"Dialogue: 0,{start_time},{end_time},Default,,{merged_subtitle_margin},{merged_subtitle_margin},0,{effect},{merged_subtitle_alignment_tag}{text}\n"
+                                                )
+                                        else:
+                                            for entry in new_entries:
+                                                start, end, text = entry
+                                                merged_subtitle_file.write(
+                                                    f"{merged_srt_index}\n{self._srt_time(start)} --> {self._srt_time(end)}\n{text}\n\n"
+                                                )
+                                                merged_srt_index += 1
+                                # Per-chapter subtitle processing for both file and ffmpeg_proc
+                                if chapter_out_file or chapter_ffmpeg_proc:
+                                    new_chapter_entries = []
+                                    self._process_subtitle_tokens(
+                                        chapter_tokens_with_timestamps,
+                                        new_chapter_entries,
+                                        self.max_subtitle_words,
+                                        fallback_end_time=chapter_current_time + chunk_dur,
+                                    )
+                                    if chapter_subtitle_file:
+                                        subtitle_format = getattr(
+                                            self, "subtitle_format", "srt"
+                                        )
+                                        if "ass" in subtitle_format:
+                                            for start, end, text in new_chapter_entries:
+                                                start_time = self._ass_time(start)
+                                                end_time = self._ass_time(end)
+                                                # Use karaoke effect for highlighting mode
+                                                effect = (
+                                                    "karaoke"
+                                                    if self.subtitle_mode
+                                                    == "Sentence + Highlighting"
+                                                    else ""
+                                                )
+                                                chapter_subtitle_file.write(
+                                                    f"Dialogue: 0,{start_time},{end_time},Default,,{chapter_subtitle_margin},{chapter_subtitle_margin},0,{effect},{chapter_subtitle_alignment_tag}{text}\n"
+                                                )
+                                        else:
+                                            for entry in new_chapter_entries:
+                                                start, end, text = entry
+                                                chapter_subtitle_file.write(
+                                                    f"{chapter_srt_index}\n{self._srt_time(start)} --> {self._srt_time(end)}\n{text}\n\n"
+                                                )
+                                                chapter_srt_index += 1
                             if merge_chapters_at_end:
-                                # Incremental subtitle writing for merged output
+                                current_time += chunk_dur
-                                new_entries = []
+                                if chapter_out_file or chapter_ffmpeg_proc:
-                                self._process_subtitle_tokens(
+                                    chapter_current_time += chunk_dur
-                                    tokens_with_timestamps,
+                            else:
-                                    new_entries,
+                                if chapter_out_file or chapter_ffmpeg_proc:
-                                    self.max_subtitle_words,
+                                    chapter_current_time += chunk_dur
-                                    fallback_end_time=chunk_start + chunk_dur,
+                            # Calculate percentage based on characters processed
-                                )
+                            percent = min(
-                                if merged_subtitle_file:
+                                int(
-                                    subtitle_format = getattr(
+                                    self.processed_char_count / self.total_char_count * 100
-                                        self, "subtitle_format", "srt"
+                                ),
-                                    )
+                                99,
-                                    if "ass" in subtitle_format:
-                                        for start, end, text in new_entries:
-                                            start_time = self._ass_time(start)
-                                            end_time = self._ass_time(end)
-                                            # Use karaoke effect for highlighting mode
-                                            effect = (
-                                                "karaoke"
-                                                if self.subtitle_mode
-                                                == "Sentence + Highlighting"
-                                                else ""
-                                            )
-                                            merged_subtitle_file.write(
-                                                f"Dialogue: 0,{start_time},{end_time},Default,,{merged_subtitle_margin},{merged_subtitle_margin},0,{effect},{merged_subtitle_alignment_tag}{text}\n"
-                                            )
-                                    else:
-                                        for entry in new_entries:
-                                            start, end, text = entry
-                                            merged_subtitle_file.write(
-                                                f"{merged_srt_index}\n{self._srt_time(start)} --> {self._srt_time(end)}\n{text}\n\n"
-                                            )
-                                            merged_srt_index += 1
-                            # Per-chapter subtitle processing for both file and ffmpeg_proc
-                            if chapter_out_file or chapter_ffmpeg_proc:
-                                new_chapter_entries = []
-                                self._process_subtitle_tokens(
-                                    chapter_tokens_with_timestamps,
-                                    new_chapter_entries,
-                                    self.max_subtitle_words,
-                                    fallback_end_time=chapter_current_time + chunk_dur,
-                                )
-                                if chapter_subtitle_file:
-                                    subtitle_format = getattr(
-                                        self, "subtitle_format", "srt"
-                                    )
-                                    if "ass" in subtitle_format:
-                                        for start, end, text in new_chapter_entries:
-                                            start_time = self._ass_time(start)
-                                            end_time = self._ass_time(end)
-                                            # Use karaoke effect for highlighting mode
-                                            effect = (
-                                                "karaoke"
-                                                if self.subtitle_mode
-                                                == "Sentence + Highlighting"
-                                                else ""
-                                            )
-                                            chapter_subtitle_file.write(
-                                                f"Dialogue: 0,{start_time},{end_time},Default,,{chapter_subtitle_margin},{chapter_subtitle_margin},0,{effect},{chapter_subtitle_alignment_tag}{text}\n"
-                                            )
-                                    else:
-                                        for entry in new_chapter_entries:
-                                            start, end, text = entry
-                                            chapter_subtitle_file.write(
-                                                f"{chapter_srt_index}\n{self._srt_time(start)} --> {self._srt_time(end)}\n{text}\n\n"
-                                            )
-                                            chapter_srt_index += 1
-                        if merge_chapters_at_end:
-                            current_time += chunk_dur
-                            if chapter_out_file or chapter_ffmpeg_proc:
-                                chapter_current_time += chunk_dur
-                        else:
-                            if chapter_out_file or chapter_ffmpeg_proc:
-                                chapter_current_time += chunk_dur
-                        # Calculate percentage based on characters processed
-                        percent = min(
-                            int(
-                                self.processed_char_count / self.total_char_count * 100
-                            ),
-                            99,
-                        )
-
-                        # Calculate ETR based on characters processed
-                        etr_str = "Processing..."
-                        chars_done = self.processed_char_count
-                        elapsed = time.time() - self.etr_start_time
-
-                        # Calculate ETR if enough data is available
-                        if (
-                            chars_done > 0 and elapsed > 0.5
-                        ):  # Check elapsed > 0.5 to avoid instability
-                            avg_time_per_char = elapsed / chars_done
-                            remaining = (
-                                self.total_char_count - self.processed_char_count
                             )
-                            if remaining > 0:
-                                secs = avg_time_per_char * remaining
-                                h = int(secs // 3600)
-                                m = int((secs % 3600) // 60)
-                                s = int(secs % 60)
-                                etr_str = f"{h:02d}:{m:02d}:{s:02d}"
 
-                        # Update progress more frequently (after each result)
+                            # Calculate ETR based on characters processed
-                        self.progress_updated.emit(percent, etr_str)
+                            etr_str = "Processing..."
+                            chars_done = self.processed_char_count
+                            elapsed = time.time() - self.etr_start_time
+
+                            # Calculate ETR if enough data is available
+                            if (
+                                chars_done > 0 and elapsed > 0.5
+                            ):  # Check elapsed > 0.5 to avoid instability
+                                avg_time_per_char = elapsed / chars_done
+                                remaining = (
+                                    self.total_char_count - self.processed_char_count
+                                )
+                                if remaining > 0:
+                                    secs = avg_time_per_char * remaining
+                                    h = int(secs // 3600)
+                                    m = int((secs % 3600) // 60)
+                                    s = int(secs % 60)
+                                    etr_str = f"{h:02d}:{m:02d}:{s:02d}"
+
+                            # Update progress more frequently (after each result)
+                            self.progress_updated.emit(percent, etr_str)
 
                 # Add silence between chapters for merged output (except after the last chapter)
                 if merge_chapters_at_end and chapter_idx < total_chapters:

abogen/pyqt/gui.py

@@ -74,7 +74,7 @@ from abogen.subtitle_utils import (
     calculate_text_length,
 )
 
-from abogen.conversion import ConversionThread, VoicePreviewThread, PlayAudioThread
+from abogen.pyqt.conversion import ConversionThread, VoicePreviewThread, PlayAudioThread, ChapterOptionsDialog, TimestampDetectionDialog
 from abogen.pyqt.book_handler import HandlerDialog
 from abogen.constants import (
     PROGRAM_NAME,
@@ -665,6 +665,11 @@ class TextboxDialog(QDialog):
         self.insert_chapter_btn.clicked.connect(self.insert_chapter_marker)
         button_layout.addWidget(self.insert_chapter_btn)
 
+        self.insert_voice_btn = QPushButton("Insert Voice Marker", self)
+        self.insert_voice_btn.setToolTip("Insert a voice change marker at the cursor position")
+        self.insert_voice_btn.clicked.connect(self.insert_voice_marker)
+        button_layout.addWidget(self.insert_voice_btn)
+
         self.cancel_button = QPushButton("Cancel", self)
         self.cancel_button.clicked.connect(self.reject)
 
@@ -767,6 +772,23 @@ class TextboxDialog(QDialog):
         self.update_char_count()
         self.text_edit.setFocus()
 
+    def insert_voice_marker(self):
+        """Insert a voice marker template at cursor position."""
+        cursor = self.text_edit.textCursor()
+        # Use the currently selected voice as the default
+        try:
+            parent_window = self.parent()
+            if parent_window and hasattr(parent_window, 'selected_voice'):
+                default_voice = parent_window.selected_voice or "af_heart"
+            else:
+                default_voice = "af_heart"
+        except Exception:
+            default_voice = "af_heart"
+        cursor.insertText(f"\n<<VOICE:{default_voice}>>\n")
+        self.text_edit.setTextCursor(cursor)
+        self.update_char_count()
+        self.text_edit.setFocus()
+
 
 def migrate_subtitle_format(config):
     """Convert old subtitle_format values to new internal keys."""
@@ -783,6 +805,108 @@ def migrate_subtitle_format(config):
         save_config(config)
 
 
+class WordSubstitutionsDialog(QDialog):
+    """Dialog for configuring word substitutions and text preprocessing options."""
+
+    def __init__(
+        self,
+        parent=None,
+        initial_list="",
+        initial_case_sensitive=False,
+        initial_caps=False,
+        initial_numerals=False,
+        initial_punctuation=False,
+    ):
+        super().__init__(parent)
+        self.setWindowTitle("Word Substitutions Settings")
+        self.setWindowFlags(
+            Qt.WindowType.Window
+            | Qt.WindowType.WindowCloseButtonHint
+            | Qt.WindowType.WindowMaximizeButtonHint
+        )
+        self.resize(600, 500)
+
+        layout = QVBoxLayout(self)
+
+        # Instructions
+        instructions = QLabel(
+            "Enter word substitutions (one per line) in format: Word|NewWord\n"
+            "  - If nothing after |, the word will be erased completely\n"
+            "  - Substitutions match whole words only (e.g., \"tree\" won't match \"trees\" but will match \"tree's\")\n"
+            "  - By default, matching is case-insensitive (e.g., \"gonna\" matches \"Gonna\", \"GONNA\", etc.)",
+            self,
+        )
+        instructions.setStyleSheet(
+            "padding: 10px; background-color: #f0f0f0; border-radius: 5px;"
+        )
+        instructions.setWordWrap(True)
+        layout.addWidget(instructions)
+
+        # Text edit area
+        self.text_edit = QTextEdit(self)
+        self.text_edit.setAcceptRichText(False)
+        self.text_edit.setPlaceholderText("Word|NewWord")
+        self.text_edit.setPlainText(initial_list)
+        layout.addWidget(self.text_edit)
+
+        # Checkboxes
+        self.case_sensitive_checkbox = QCheckBox(
+            "Case-sensitive word matching", self
+        )
+        self.case_sensitive_checkbox.setChecked(initial_case_sensitive)
+        layout.addWidget(self.case_sensitive_checkbox)
+
+        self.caps_checkbox = QCheckBox("Replace ALL CAPS with lowercase", self)
+        self.caps_checkbox.setChecked(initial_caps)
+        layout.addWidget(self.caps_checkbox)
+
+        self.numerals_checkbox = QCheckBox(
+            "Replace Numerals with Words (e.g., 309 \u2192 three hundred and nine)", self
+        )
+        self.numerals_checkbox.setChecked(initial_numerals)
+        layout.addWidget(self.numerals_checkbox)
+
+        self.punctuation_checkbox = QCheckBox(
+            "Fix Nonstandard Punctuation (curly quotes and other Unicode punctuation that may affect how words sound)",
+            self,
+        )
+        self.punctuation_checkbox.setChecked(initial_punctuation)
+        layout.addWidget(self.punctuation_checkbox)
+
+        # Buttons
+        button_layout = QHBoxLayout()
+        self.cancel_button = QPushButton("Cancel", self)
+        self.cancel_button.clicked.connect(self.reject)
+        self.ok_button = QPushButton("OK", self)
+        self.ok_button.setDefault(True)
+        self.ok_button.clicked.connect(self.accept)
+
+        button_layout.addStretch()
+        button_layout.addWidget(self.cancel_button)
+        button_layout.addWidget(self.ok_button)
+        layout.addLayout(button_layout)
+
+    def get_substitutions_list(self):
+        """Get the substitutions list as plain text."""
+        return self.text_edit.toPlainText()
+
+    def get_case_sensitive(self):
+        """Get whether case-sensitive matching is enabled."""
+        return self.case_sensitive_checkbox.isChecked()
+
+    def get_replace_all_caps(self):
+        """Get whether ALL CAPS replacement is enabled."""
+        return self.caps_checkbox.isChecked()
+
+    def get_replace_numerals(self):
+        """Get whether numeral-to-word conversion is enabled."""
+        return self.numerals_checkbox.isChecked()
+
+    def get_fix_nonstandard_punctuation(self):
+        """Get whether nonstandard punctuation fixing is enabled."""
+        return self.punctuation_checkbox.isChecked()
+
+
 class abogen(QWidget):
     def __init__(self):
         super().__init__()
@@ -833,6 +957,19 @@ class abogen(QWidget):
         self.use_silent_gaps = self.config.get("use_silent_gaps", True)
         self.subtitle_speed_method = self.config.get("subtitle_speed_method", "tts")
         self.use_spacy_segmentation = self.config.get("use_spacy_segmentation", True)
+        # Word substitution settings
+        self.word_substitutions_enabled = self.config.get(
+            "word_substitutions_enabled", False
+        )
+        self.word_substitutions_list = self.config.get("word_substitutions_list", "")
+        self.case_sensitive_substitutions = self.config.get(
+            "case_sensitive_substitutions", False
+        )
+        self.replace_all_caps = self.config.get("replace_all_caps", False)
+        self.replace_numerals = self.config.get("replace_numerals", False)
+        self.fix_nonstandard_punctuation = self.config.get(
+            "fix_nonstandard_punctuation", False
+        )
         self._pending_close_event = None
         self.gpu_ok = False  # Initialize GPU availability status
 
@@ -1071,6 +1208,35 @@ class abogen(QWidget):
         subtitle_layout.addWidget(self.subtitle_combo)
         controls_layout.addLayout(subtitle_layout)
 
+        # Word Substitutions section
+        word_sub_layout = QHBoxLayout()
+        word_sub_layout.setSpacing(7)
+        word_sub_label = QLabel("Word Substitutions:", self)
+        word_sub_layout.addWidget(word_sub_label)
+
+        self.word_sub_combo = QComboBox(self)
+        self.word_sub_combo.addItems(["Disabled", "Enabled"])
+        self.word_sub_combo.setStyleSheet(
+            "QComboBox { min-height: 20px; padding: 6px 12px; }"
+        )
+        self.word_sub_combo.setSizePolicy(
+            QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed
+        )
+        self.word_sub_combo.setCurrentText(
+            "Enabled" if self.word_substitutions_enabled else "Disabled"
+        )
+        self.word_sub_combo.currentTextChanged.connect(self.on_word_sub_changed)
+        word_sub_layout.addWidget(self.word_sub_combo)
+
+        self.btn_word_sub_settings = QPushButton("Settings", self)
+        self.btn_word_sub_settings.setFixedSize(80, 36)
+        self.btn_word_sub_settings.setStyleSheet("QPushButton { padding: 6px 12px; }")
+        self.btn_word_sub_settings.clicked.connect(self.show_word_sub_dialog)
+        self.btn_word_sub_settings.setEnabled(self.word_substitutions_enabled)
+        word_sub_layout.addWidget(self.btn_word_sub_settings)
+
+        controls_layout.addLayout(word_sub_layout)
+
         # Output voice format
         format_layout = QHBoxLayout()
         format_layout.setSpacing(7)
@@ -2015,15 +2181,37 @@ class abogen(QWidget):
                 self.subtitle_speed_method = getattr(
                     queued_item, "subtitle_speed_method", "tts"
                 )
+                # Word substitution settings
+                self.word_substitutions_enabled = getattr(
+                    queued_item, "word_substitutions_enabled", False
+                )
+                self.word_substitutions_list = getattr(
+                    queued_item, "word_substitutions_list", ""
+                )
+                self.case_sensitive_substitutions = getattr(
+                    queued_item, "case_sensitive_substitutions", False
+                )
+                self.replace_all_caps = getattr(queued_item, "replace_all_caps", False)
+                self.replace_numerals = getattr(queued_item, "replace_numerals", False)
+                self.fix_nonstandard_punctuation = getattr(
+                    queued_item, "fix_nonstandard_punctuation", False
+                )
 
-                # This ensures that if conversion.py (or utils) reads from config/disk 
+                # This ensures that if conversion.py (or utils) reads from config/disk
                 # instead of using passed arguments, it sees the correct queue values.
                 self.config["replace_single_newlines"] = self.replace_single_newlines
                 self.config["subtitle_mode"] = self.subtitle_mode
                 self.config["selected_format"] = self.selected_format
                 self.config["use_silent_gaps"] = self.use_silent_gaps
                 self.config["subtitle_speed_method"] = self.subtitle_speed_method
-                
+                # Word substitution settings
+                self.config["word_substitutions_enabled"] = self.word_substitutions_enabled
+                self.config["word_substitutions_list"] = self.word_substitutions_list
+                self.config["case_sensitive_substitutions"] = self.case_sensitive_substitutions
+                self.config["replace_all_caps"] = self.replace_all_caps
+                self.config["replace_numerals"] = self.replace_numerals
+                self.config["fix_nonstandard_punctuation"] = self.fix_nonstandard_punctuation
+
                 # Sync Voice/Profile in config
                 self.config["selected_voice"] = self.selected_voice
                 if "selected_profile_name" in self.config:
@@ -2179,6 +2367,21 @@ class abogen(QWidget):
             self.conversion_thread.subtitle_speed_method = self.subtitle_speed_method
             # Pass use_spacy_segmentation setting
             self.conversion_thread.use_spacy_segmentation = self.use_spacy_segmentation
+            # Pass word substitution settings
+            self.conversion_thread.word_substitutions_enabled = (
+                self.word_substitutions_enabled
+            )
+            self.conversion_thread.word_substitutions_list = (
+                self.word_substitutions_list
+            )
+            self.conversion_thread.case_sensitive_substitutions = (
+                self.case_sensitive_substitutions
+            )
+            self.conversion_thread.replace_all_caps = self.replace_all_caps
+            self.conversion_thread.replace_numerals = self.replace_numerals
+            self.conversion_thread.fix_nonstandard_punctuation = (
+                self.fix_nonstandard_punctuation
+            )
             # Pass separate_chapters_format setting
             self.conversion_thread.separate_chapters_format = (
                 self.separate_chapters_format
@@ -2927,6 +3130,41 @@ class abogen(QWidget):
         self.config["use_gpu"] = self.use_gpu
         save_config(self.config)
 
+    def on_word_sub_changed(self, text):
+        """Handle word substitution dropdown change."""
+        self.word_substitutions_enabled = text == "Enabled"
+        self.btn_word_sub_settings.setEnabled(self.word_substitutions_enabled)
+
+        # Save to config
+        self.config["word_substitutions_enabled"] = self.word_substitutions_enabled
+        save_config(self.config)
+
+    def show_word_sub_dialog(self):
+        """Show word substitutions settings dialog."""
+        dialog = WordSubstitutionsDialog(
+            self,
+            initial_list=self.word_substitutions_list,
+            initial_case_sensitive=self.case_sensitive_substitutions,
+            initial_caps=self.replace_all_caps,
+            initial_numerals=self.replace_numerals,
+            initial_punctuation=self.fix_nonstandard_punctuation,
+        )
+
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            self.word_substitutions_list = dialog.get_substitutions_list()
+            self.case_sensitive_substitutions = dialog.get_case_sensitive()
+            self.replace_all_caps = dialog.get_replace_all_caps()
+            self.replace_numerals = dialog.get_replace_numerals()
+            self.fix_nonstandard_punctuation = dialog.get_fix_nonstandard_punctuation()
+
+            # Save all settings to config
+            self.config["word_substitutions_list"] = self.word_substitutions_list
+            self.config["case_sensitive_substitutions"] = self.case_sensitive_substitutions
+            self.config["replace_all_caps"] = self.replace_all_caps
+            self.config["replace_numerals"] = self.replace_numerals
+            self.config["fix_nonstandard_punctuation"] = self.fix_nonstandard_punctuation
+            save_config(self.config)
+
     def cleanup_conversion_thread(self):
         # Stop conversion thread
         if (
@@ -2991,8 +3229,6 @@ class abogen(QWidget):
         """Show dialog to ask user about chapter processing options when chapters are detected in a .txt file"""
         # Check if this is a timestamp detection (-1) or chapter detection
         if chapter_count == -1:
-            from abogen.conversion import TimestampDetectionDialog
-
             dialog = TimestampDetectionDialog(parent=self)
             dialog.setWindowModality(Qt.WindowModality.ApplicationModal)
 
@@ -3007,8 +3243,6 @@ class abogen(QWidget):
             return
 
         # Normal chapter detection
-        from abogen.conversion import ChapterOptionsDialog
-
         dialog = ChapterOptionsDialog(chapter_count, parent=self)
         dialog.setWindowModality(Qt.WindowModality.ApplicationModal)
 

abogen/pyqt/queue_manager_gui.py

@@ -35,6 +35,12 @@ OVERRIDE_FIELDS = [
     "replace_single_newlines",
     "use_silent_gaps",
     "subtitle_speed_method",
+    "word_substitutions_enabled",
+    "word_substitutions_list",
+    "case_sensitive_substitutions",
+    "replace_all_caps",
+    "replace_numerals",
+    "fix_nonstandard_punctuation",
 ]
 
 
@@ -474,6 +480,21 @@ class QueueManager(QDialog):
             attrs["subtitle_speed_method"] = getattr(
                 parent, "subtitle_speed_method", "tts"
             )
+            # word substitutions
+            attrs["word_substitutions_enabled"] = getattr(
+                parent, "word_substitutions_enabled", False
+            )
+            attrs["word_substitutions_list"] = getattr(
+                parent, "word_substitutions_list", ""
+            )
+            attrs["case_sensitive_substitutions"] = getattr(
+                parent, "case_sensitive_substitutions", False
+            )
+            attrs["replace_all_caps"] = getattr(parent, "replace_all_caps", False)
+            attrs["replace_numerals"] = getattr(parent, "replace_numerals", False)
+            attrs["fix_nonstandard_punctuation"] = getattr(
+                parent, "fix_nonstandard_punctuation", False
+            )
             # book handler options
             attrs["save_chapters_separately"] = getattr(
                 parent, "save_chapters_separately", None

abogen/pyqt/queued_item.py

@@ -19,3 +19,10 @@ class QueuedItem:
     save_base_path: str = None
     save_chapters_separately: bool = None
     merge_chapters_at_end: bool = None
+    # Word Substitution fields
+    word_substitutions_enabled: bool = False
+    word_substitutions_list: str = ""
+    case_sensitive_substitutions: bool = False
+    replace_all_caps: bool = False
+    replace_numerals: bool = False
+    fix_nonstandard_punctuation: bool = False

abogen/subtitle_utils.py

@@ -15,6 +15,8 @@ _ASS_STYLING_PATTERN = re.compile(r"\{[^}]+\}")
 _ASS_NEWLINE_N_PATTERN = re.compile(r"\\N")
 _ASS_NEWLINE_LOWER_N_PATTERN = re.compile(r"\\n")
 _CHAPTER_MARKER_SEARCH_PATTERN = re.compile(r"<<CHAPTER_MARKER:(.*?)>>")
+_VOICE_MARKER_PATTERN = re.compile(r"<<VOICE:[^>]*>>")
+_VOICE_MARKER_SEARCH_PATTERN = re.compile(r"<<VOICE:(.*?)>>")
 _WEBVTT_HEADER_PATTERN = re.compile(r"^WEBVTT.*?\n", re.MULTILINE)
 _VTT_STYLE_PATTERN = re.compile(r"STYLE\s*\n.*?(?=\n\n|$)", re.DOTALL)
 _VTT_NOTE_PATTERN = re.compile(r"NOTE\s*\n.*?(?=\n\n|$)", re.DOTALL)
@@ -31,17 +33,19 @@ _LINUX_ILLEGAL_CHARS_PATTERN = re.compile(r"[/\x00]")
 
 
 def clean_subtitle_text(text):
-    """Remove chapter markers and metadata tags from subtitle text."""
+    """Remove chapter markers, voice markers, and metadata tags from subtitle text."""
     # Use pre-compiled patterns for better performance
     text = _METADATA_TAG_PATTERN.sub("", text)
     text = _CHAPTER_MARKER_PATTERN.sub("", text)
+    text = _VOICE_MARKER_PATTERN.sub("", text)
     return text.strip()
 
 
 def calculate_text_length(text):
     # Use pre-compiled patterns for better performance
-    # Ignore chapter markers and metadata patterns in a single pass
+    # Ignore chapter markers, voice markers, and metadata patterns in a single pass
     text = _CHAPTER_MARKER_PATTERN.sub("", text)
+    text = _VOICE_MARKER_PATTERN.sub("", text)
     text = _METADATA_TAG_PATTERN.sub("", text)
     # Ignore newlines and leading/trailing spaces
     text = text.replace("\n", "").strip()
@@ -459,3 +463,122 @@ def sanitize_name_for_os(name, is_folder=True):
         sanitized = sanitized[:255].rstrip(". ")
 
     return sanitized
+
+
+def validate_voice_name(voice_name):
+    """Validate voice name against VOICES_INTERNAL list (case-insensitive).
+    Handles both single voices and formulas like 'af_heart*0.5 + am_echo*0.5'.
+
+    Args:
+        voice_name: Voice name or formula string to validate
+
+    Returns:
+        Tuple of (is_valid, invalid_voice_name):
+            - is_valid: True if all voices in the name/formula are valid
+            - invalid_voice_name: The first invalid voice found, or None if all valid
+    """
+    from abogen.constants import VOICES_INTERNAL
+
+    # Create case-insensitive lookup set (done once per call)
+    voice_lookup_lower = {v.lower() for v in VOICES_INTERNAL}
+    voice_name = voice_name.strip()
+
+    # Check if it's a formula (contains *)
+    if "*" in voice_name:
+        # Extract voice names from formula
+        voices = voice_name.split("+")
+        for term in voices:
+            if "*" in term:
+                base_voice = term.split("*")[0].strip()
+                # Case-insensitive comparison
+                if base_voice.lower() not in voice_lookup_lower:
+                    return False, base_voice
+        return True, None
+    else:
+        # Single voice - case-insensitive comparison
+        if voice_name.lower() not in voice_lookup_lower:
+            return False, voice_name
+        return True, None
+
+
+def split_text_by_voice_markers(text, default_voice):
+    """Split text by voice markers, returning list of (voice, text) tuples.
+
+    IMPORTANT: Returns the last voice used so it can persist across chapters.
+    Voice names are normalized to lowercase to match VOICES_INTERNAL.
+
+    Args:
+        text: Text potentially containing <<VOICE:name>> markers
+        default_voice: Voice to use if no markers found or before first marker
+
+    Returns:
+        Tuple of (segments_list, last_voice_used, valid_count, invalid_count):
+            - segments_list: List of (voice_name, segment_text) tuples
+            - last_voice_used: The voice that should continue into next chapter
+            - valid_count: Number of valid voice markers processed
+            - invalid_count: Number of invalid voice markers skipped
+    """
+    from abogen.constants import VOICES_INTERNAL
+
+    voice_splits = list(_VOICE_MARKER_SEARCH_PATTERN.finditer(text))
+
+    if not voice_splits:
+        # No voice markers, return entire text with default voice
+        return [(default_voice, text)], default_voice, 0, 0
+
+    segments = []
+    current_voice = default_voice
+    valid_markers = 0
+    invalid_markers = 0
+
+    # Text before first marker uses default voice
+    first_start = voice_splits[0].start()
+    if first_start > 0:
+        intro_text = text[:first_start].strip()
+        if intro_text:
+            segments.append((current_voice, intro_text))
+
+    # Process each voice marker
+    for idx, match in enumerate(voice_splits):
+        voice_name = match.group(1).strip()
+        start = match.end()
+        end = voice_splits[idx + 1].start() if idx + 1 < len(voice_splits) else len(text)
+        segment_text = text[start:end].strip()
+
+        # Validate voice name
+        is_valid, invalid_voice = validate_voice_name(voice_name)
+        if is_valid:
+            # Normalize to lowercase to match canonical form
+            # Handle both single voices and formulas
+            if "*" in voice_name:
+                # Normalize each voice in the formula
+                normalized_parts = []
+                for part in voice_name.split("+"):
+                    part = part.strip()
+                    if "*" in part:
+                        voice_part, weight = part.split("*", 1)
+                        # Find the canonical (lowercase) voice name
+                        voice_part_lower = voice_part.strip().lower()
+                        canonical_voice = next(
+                            (v for v in VOICES_INTERNAL if v.lower() == voice_part_lower),
+                            voice_part.strip()
+                        )
+                        normalized_parts.append(f"{canonical_voice}*{weight.strip()}")
+                current_voice = " + ".join(normalized_parts)
+            else:
+                # Find the canonical (lowercase) voice name
+                voice_name_lower = voice_name.lower()
+                current_voice = next(
+                    (v for v in VOICES_INTERNAL if v.lower() == voice_name_lower),
+                    voice_name
+                )
+            valid_markers += 1
+        else:
+            # Invalid voice - stay with previous voice
+            invalid_markers += 1
+
+        if segment_text:
+            segments.append((current_voice, segment_text))
+
+    # Return segments, last voice, and counts
+    return segments, current_voice, valid_markers, invalid_markers

abogen/text_extractor.py

@@ -1023,8 +1023,13 @@ class EpubExtractor:
         if not html:
             return ""
         soup = BeautifulSoup(html, "html.parser")
-        for tag in soup.find_all(["p", "div"]):
+
+        # Add line breaks after block-level elements to ensure pauses in speech
+        for tag in soup.find_all(
+            ["p", "div", "h1", "h2", "h3", "h4", "h5", "h6", "li", "blockquote"]
+        ):
             tag.append("\n\n")
+
         for ol in soup.find_all("ol"):
             start_attr = ol.get("start")
             try:

abogen/tts_backend.py

@@ -0,0 +1,117 @@
+"""
+Minimal TTS Backend Interface
+
+This module defines a minimal interface for TTS backends to enable future
+extensibility while maintaining backward compatibility with existing Kokoro
+implementation.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Iterator, Optional, Union
+
+
+class TTSBackend(ABC):
+    """
+    Minimal interface for TTS backends.
+    
+    This interface is designed to be minimal and focused on the essential
+    operations needed for text-to-speech conversion.
+    """
+
+    @abstractmethod
+    def __call__(
+        self,
+        text: str,
+        voice: Union[str, Any],
+        speed: float = 1.0,
+        **kwargs: Any
+    ) -> Iterator[Any]:
+        """
+        Generate speech segments from text.
+        
+        Args:
+            text: Text to convert to speech
+            voice: Voice specification or object
+            speed: Speed multiplier for speech
+            **kwargs: Additional backend-specific parameters
+            
+        Yields:
+            Speech segments (audio data, timing info, etc.)
+        """
+        pass
+
+
+class KokoroTTSBackend(TTSBackend):
+    """
+    Implementation of TTSBackend using Kokoro.
+    
+    This class provides the concrete implementation that maintains
+    the existing behavior while conforming to the TTSBackend interface.
+    """
+
+    def __init__(self, lang_code: str, repo_id: str = "hexgrad/Kokoro-82M", device: str = "cpu"):
+        """
+        Initialize Kokoro backend.
+        
+        Args:
+            lang_code: Language code for the model
+            repo_id: Repository ID for the Kokoro model
+            device: Device to run the model on (cpu, cuda, etc.)
+        """
+        self.lang_code = lang_code
+        self.repo_id = repo_id
+        self.device = device
+        self._pipeline = None
+
+    def _get_pipeline(self):
+        """Lazy initialization of the Kokoro pipeline."""
+        if self._pipeline is None:
+            from abogen.utils import load_numpy_kpipeline
+            _, KPipeline = load_numpy_kpipeline()
+            try:
+                self._pipeline = KPipeline(
+                    lang_code=self.lang_code,
+                    repo_id=self.repo_id,
+                    device=self.device
+                )
+            except RuntimeError as e:
+                if "CUDA" in str(e) and self.device != "cpu":
+                    # Fall back to CPU if CUDA fails
+                    self._pipeline = KPipeline(
+                        lang_code=self.lang_code,
+                        repo_id=self.repo_id,
+                        device="cpu"
+                    )
+                else:
+                    raise
+        return self._pipeline
+
+    def __call__(
+        self,
+        text: str,
+        voice: Union[str, Any],
+        speed: float = 1.0,
+        split_pattern: str = r"\n+",
+        **kwargs: Any
+    ) -> Iterator[Any]:
+        """
+        Generate speech segments from text using Kokoro.
+        
+        Args:
+            text: Text to convert to speech
+            voice: Voice specification or object
+            speed: Speed multiplier for speech
+            split_pattern: Pattern to split text into segments
+            **kwargs: Additional parameters passed to the pipeline
+            
+        Yields:
+            Speech segments
+        """
+        pipeline = self._get_pipeline()
+        return pipeline(
+            text,
+            voice=voice,
+            speed=speed,
+            split_pattern=split_pattern,
+            **kwargs
+        )

abogen/webui/conversion_runner.py

@@ -41,6 +41,7 @@ from abogen.utils import (
     load_config,
     load_numpy_kpipeline,
 )
+from abogen.tts_backend import KokoroTTSBackend
 from abogen.voice_cache import ensure_voice_assets
 from abogen.voice_formulas import extract_voice_ids, get_new_voice
 from abogen.voice_profiles import load_profiles, normalize_profile_entry
@@ -1594,16 +1595,12 @@ def run_conversion_job(job: Job) -> None:
             device = "cpu"
             if not disable_gpu:
                 device = _select_device()
-            _np, KPipeline = load_numpy_kpipeline()
+            # Create KokoroTTSBackend instance instead of directly instantiating KPipeline
-            # Try to initialize with the selected device; fall back to CPU if CUDA fails
+            pipelines[provider_norm] = KokoroTTSBackend(
-            try:
+                lang_code=job.language,
-                pipelines[provider_norm] = KPipeline(lang_code=job.language, repo_id="hexgrad/Kokoro-82M", device=device)
+                repo_id="hexgrad/Kokoro-82M",
-            except RuntimeError as e:
+                device=device
-                if "CUDA" in str(e) and device != "cpu":
+            )
-                    job.add_log(f"CUDA initialization failed, falling back to CPU: {e}", level="warning")
-                    pipelines[provider_norm] = KPipeline(lang_code=job.language, repo_id="hexgrad/Kokoro-82M", device="cpu")
-                else:
-                    raise
             if not kokoro_cache_ready:
                 _initialize_voice_cache(job)
                 kokoro_cache_ready = True
@@ -1644,8 +1641,8 @@ def run_conversion_job(job: Job) -> None:
                 return provider, resolved, cached, speed, steps
 
             if provider == "kokoro":
-                kokoro_pipeline = get_pipeline("kokoro")
+                kokoro_backend = get_pipeline("kokoro")
-                choice = _resolve_voice(kokoro_pipeline, resolved, job.use_gpu)
+                choice = _resolve_voice(kokoro_backend, resolved, job.use_gpu)
             else:
                 choice = resolved
 
@@ -1774,8 +1771,8 @@ def run_conversion_job(job: Job) -> None:
         voice_cache: Dict[str, Any] = {}
         base_provider, base_voice_resolved, _, _ = resolve_voice_target(base_voice_spec)
         if base_provider == "kokoro" and base_voice_resolved and "*" not in base_voice_resolved:
-            kokoro_pipeline = get_pipeline("kokoro")
+            kokoro_backend = get_pipeline("kokoro")
-            voice_cache[f"kokoro:{base_voice_resolved}"] = _resolve_voice(kokoro_pipeline, base_voice_resolved, job.use_gpu)
+            voice_cache[f"kokoro:{base_voice_resolved}"] = _resolve_voice(kokoro_backend, base_voice_resolved, job.use_gpu)
         processed_chars = 0
         subtitle_index = 1
         current_time = 0.0
@@ -1860,8 +1857,8 @@ def run_conversion_job(job: Job) -> None:
                     total_steps=int(supertonic_steps_override if supertonic_steps_override is not None else getattr(job, "supertonic_total_steps", 5)),
                 )
             else:
-                kokoro_pipeline = get_pipeline("kokoro")
+                kokoro_backend = get_pipeline("kokoro")
-                segment_iter = kokoro_pipeline(
+                segment_iter = kokoro_backend(
                     normalized,
                     voice=voice_choice,
                     speed=float(speed_override if speed_override is not None else job.speed),
@@ -1950,8 +1947,8 @@ def run_conversion_job(job: Job) -> None:
             if chapter_provider == "kokoro":
                 voice_choice = voice_cache.get(chapter_cache_key)
                 if voice_choice is None:
-                    kokoro_pipeline = get_pipeline("kokoro")
+                    kokoro_backend = get_pipeline("kokoro")
-                    voice_choice = _resolve_voice(kokoro_pipeline, chapter_voice_resolved, job.use_gpu)
+                    voice_choice = _resolve_voice(kokoro_backend, chapter_voice_resolved, job.use_gpu)
                     voice_cache[chapter_cache_key] = voice_choice
             else:
                 voice_choice = chapter_voice_resolved
@@ -2095,9 +2092,9 @@ def run_conversion_job(job: Job) -> None:
                         if chunk_provider == "kokoro":
                             chunk_voice_choice = voice_cache.get(chunk_cache_key)
                             if chunk_voice_choice is None:
-                                kokoro_pipeline = get_pipeline("kokoro")
+                                kokoro_backend = get_pipeline("kokoro")
                                 chunk_voice_choice = _resolve_voice(
-                                    kokoro_pipeline,
+                                    kokoro_backend,
                                     chunk_voice_resolved,
                                     job.use_gpu,
                                 )

abogen/webui/routes/utils/preview.py

@@ -17,10 +17,43 @@ _preview_pipeline_lock = threading.Lock()
 def _select_device() -> str:
     import platform
 
+    try:
+        import torch  # type: ignore[import-not-found]
+    except Exception:
+        return "cpu"
+
     system = platform.system()
     if system == "Darwin" and platform.processor() == "arm":
-        return "mps"
+        try:
-    return "cuda"
+            if torch.backends.mps.is_available():
+                return "mps"
+        except Exception:
+            pass
+        return "cpu"
+
+    try:
+        if torch.cuda.is_available():
+            return "cuda"
+    except Exception:
+        pass
+    return "cpu"
+
+
+def _resolve_pipeline(language: str, use_gpu: bool) -> Tuple[Any, bool]:
+    devices: List[str] = ["cpu"]
+    if use_gpu:
+        preferred = _select_device()
+        if preferred != "cpu":
+            devices.insert(0, preferred)
+
+    last_error: Optional[Exception] = None
+    for device in devices:
+        try:
+            return get_preview_pipeline(language, device), device != "cpu"
+        except Exception as exc:
+            last_error = exc
+
+    raise RuntimeError("Preview pipeline is unavailable") from last_error
 
 
 def _to_float32(audio_segment) -> np.ndarray:
@@ -115,15 +148,7 @@ def generate_preview_audio(
             total_steps=supertonic_total_steps,
         )
     else:
-        device = "cpu"
+        pipeline, pipeline_uses_gpu = _resolve_pipeline(language, use_gpu)
-        if use_gpu:
-            try:
-                device = _select_device()
-            except Exception:
-                device = "cpu"
-                use_gpu = False
-
-        pipeline = get_preview_pipeline(language, device)
         if pipeline is None:
             raise RuntimeError("Preview pipeline is unavailable")
 
@@ -131,7 +156,7 @@ def generate_preview_audio(
         if voice_spec and "*" in voice_spec:
             from abogen.voice_formulas import get_new_voice
 
-            voice_choice = get_new_voice(pipeline, voice_spec, use_gpu)
+            voice_choice = get_new_voice(pipeline, voice_spec, pipeline_uses_gpu)
 
         segments = pipeline(
             normalized_text,

abogen/word_substitution.py

@@ -0,0 +1,254 @@
+"""
+Word substitution module for text-to-speech preprocessing.
+
+This module provides functionality to:
+- Replace words/phrases with custom text
+- Convert ALL CAPS to lowercase
+- Convert numerals to words
+- Fix nonstandard punctuation for TTS compatibility
+
+All substitutions preserve special markers (chapter, voice, metadata, timestamps).
+"""
+
+import re
+
+from abogen.subtitle_utils import (
+    _CHAPTER_MARKER_PATTERN,
+    _VOICE_MARKER_PATTERN,
+    _METADATA_TAG_PATTERN,
+    _TIMESTAMP_ONLY_PATTERN,
+)
+
+
+def apply_word_substitutions(
+    text,
+    substitutions_list_str,
+    case_sensitive=False,
+    replace_all_caps=False,
+    replace_numerals=False,
+    fix_nonstandard_punctuation=False,
+):
+    """
+    Apply word substitutions to text while preserving markers.
+
+    Args:
+        text: Input text
+        substitutions_list_str: Newline-separated "Word|NewWord" pairs
+        case_sensitive: If True, match words case-sensitively
+        replace_all_caps: Convert ALL CAPS words to lowercase
+        replace_numerals: Convert numbers to words
+        fix_nonstandard_punctuation: Fix curly quotes, em/en dashes, etc.
+
+    Returns:
+        Modified text
+    """
+    # Apply nonstandard punctuation fixes FIRST (if enabled)
+    if fix_nonstandard_punctuation:
+        text = fix_punctuation(text)
+
+    # Parse substitutions list
+    substitutions = parse_substitutions_list(substitutions_list_str)
+
+    # Split text into segments (markers vs content)
+    segments = split_text_preserving_markers(text)
+
+    # Process each segment
+    processed_segments = []
+    for segment_type, segment_text in segments:
+        if segment_type == "marker":
+            # Preserve markers unchanged
+            processed_segments.append(segment_text)
+        else:
+            # Apply substitutions to content
+            processed_text = segment_text
+
+            # Apply word substitutions
+            if substitutions:
+                processed_text = apply_word_replacements(
+                    processed_text, substitutions, case_sensitive
+                )
+
+            # Apply ALL CAPS conversion
+            if replace_all_caps:
+                processed_text = convert_all_caps_to_lowercase(processed_text)
+
+            # Apply numeral conversion
+            if replace_numerals:
+                processed_text = convert_numerals_to_words(processed_text)
+
+            processed_segments.append(processed_text)
+
+    return "".join(processed_segments)
+
+
+def parse_substitutions_list(substitutions_str):
+    """
+    Parse newline-separated "Word|NewWord" format.
+
+    Args:
+        substitutions_str: String with substitutions, one per line
+
+    Returns:
+        List of tuples: [(word, replacement), ...]
+    """
+    substitutions = []
+    for line in substitutions_str.strip().split("\n"):
+        line = line.strip()
+        if not line or "|" not in line:
+            continue
+
+        parts = line.split("|", 1)
+        if len(parts) == 2:
+            word = parts[0].strip()
+            replacement = parts[1].strip()
+            if word:  # Only add if word is not empty
+                substitutions.append((word, replacement))
+
+    return substitutions
+
+
+def split_text_preserving_markers(text):
+    """
+    Split text into segments alternating between markers and content.
+
+    Args:
+        text: Input text with potential markers
+
+    Returns:
+        List of tuples: [("marker"|"content", text), ...]
+    """
+    # Combined pattern for all markers and timestamps
+    marker_pattern = re.compile(
+        r"(<<CHAPTER_MARKER:[^>]*>>|<<VOICE:[^>]*>>|<<METADATA_[^:]+:[^>]*>>|\d{1,2}:\d{2}:\d{2}(?:[.,]\d{1,3})?)"
+    )
+
+    segments = []
+    last_end = 0
+
+    for match in marker_pattern.finditer(text):
+        # Content before marker
+        if match.start() > last_end:
+            segments.append(("content", text[last_end : match.start()]))
+
+        # Marker itself
+        segments.append(("marker", match.group(0)))
+        last_end = match.end()
+
+    # Remaining content after last marker
+    if last_end < len(text):
+        segments.append(("content", text[last_end:]))
+
+    return segments
+
+
+def apply_word_replacements(text, substitutions, case_sensitive=False):
+    """
+    Apply word substitutions using whole-word matching.
+
+    Args:
+        text: Input text
+        substitutions: List of (word, replacement) tuples
+        case_sensitive: If True, match case-sensitively
+
+    Returns:
+        Text with substitutions applied
+    """
+    for word, replacement in substitutions:
+        # Use word boundaries for exact matching
+        # Escape special regex characters
+        escaped_word = re.escape(word)
+        pattern = re.compile(
+            r"\b" + escaped_word + r"\b",
+            0 if case_sensitive else re.IGNORECASE,
+        )
+        text = pattern.sub(replacement, text)
+
+    return text
+
+
+def convert_all_caps_to_lowercase(text):
+    """
+    Convert ALL CAPS words to lowercase.
+
+    Args:
+        text: Input text
+
+    Returns:
+        Text with ALL CAPS converted to lowercase
+    """
+
+    def replace_caps(match):
+        word = match.group(0)
+        # Convert to lowercase
+        return word.lower()
+
+    # Match words that are ALL CAPS (2+ letters)
+    pattern = re.compile(r"\b[A-Z]{2,}\b")
+    return pattern.sub(replace_caps, text)
+
+
+def convert_numerals_to_words(text):
+    """
+    Convert numerals to words using num2words library.
+
+    Args:
+        text: Input text
+
+    Returns:
+        Text with numerals converted to words
+    """
+    try:
+        from num2words import num2words
+    except ImportError:
+        # If num2words not available, return unchanged
+        return text
+
+    def replace_number(match):
+        try:
+            number = int(match.group(0))
+            # Convert to words in English
+            return num2words(number)
+        except Exception:
+            # If conversion fails, return original
+            return match.group(0)
+
+    # Match integers (but not timestamps or other patterns)
+    # Negative lookbehind/ahead to avoid timestamps
+    pattern = re.compile(r"(?<!\d:)\b\d+\b(?!:\d)")
+    return pattern.sub(replace_number, text)
+
+
+def fix_punctuation(text):
+    """
+    Convert nonstandard punctuation to standard equivalents.
+
+    This helps TTS engines pronounce words correctly by converting:
+    - Curly quotes to straight quotes
+    - Ellipsis to three periods
+
+    Args:
+        text: Input text
+
+    Returns:
+        Text with nonstandard punctuation fixed
+    """
+    # Define replacements
+    replacements = {
+        # Curly double quotes
+        "\u201c": '"',  # Left double quotation mark
+        "\u201d": '"',  # Right double quotation mark
+        "\u201e": '"',  # Double low-9 quotation mark
+        # Curly single quotes
+        "\u2018": "'",  # Left single quotation mark
+        "\u2019": "'",  # Right single quotation mark
+        "\u201a": "'",  # Single low-9 quotation mark
+        "\u201b": "'",  # Single high-reversed-9 quotation mark
+        # Other punctuation
+        "\u2026": "...",  # Ellipsis
+    }
+
+    # Apply all replacements
+    for old_char, new_char in replacements.items():
+        text = text.replace(old_char, new_char)
+
+    return text

pyproject.toml

@@ -96,8 +96,6 @@ exclude = [
 [tool.hatch.build.targets.wheel]
 packages = ["abogen"]
 
-[tool.hatch.build]
-include = ["abogen/webui/templates/**", "abogen/webui/static/**"]
 
 [tool.hatch.version]
 path = "abogen/VERSION"