Update CHANGELOG.md

- Added new output format: `m4b`, enabling chapter metadata in audiobooks. Special thanks to @jborza for implementing this feature in PR #10.
- Better approach for determining the correct configuration folder for Linux and MacOS, using platformdirs. (Fixes Docker issue #12)
- Improvements in documentation and code.

CHANGELOG.md

@@ -1,5 +1,56 @@
-- Added `abogen-cli` command for better troubleshooting and error handling.
+# v1.0.7
+- Improve chaptered audio generation by outputting directly as `m4b` instead of converting from `wav`.
+- Ignore chapter markers and single newlines when calculating text length, improving the accuracy of the text length calculation.
+- Prevent cancellation if process is at 99%, ensuring the process is not interrupted at the last moment.
+- Improved process handling for subpprocess calls, ensuring better management of subprocesses.
+- Improved PDF handling, ignoring empty pages/chapters and better chapter handling.
+- Added `Save in a project folder with metadata` option in the book handler, allowing users to save the converted items in a project folder with available metadata files. Useful if you want to work with the converted files in the future, issue mentioned by @Darthagnon in #15
+- Added `Go to folder` button in input box, allowing users to open the folder containing the converted file.
+- Added `.opus` as output format for generated audio files, which is a more efficient format for audio files.
+- Added `Create desktop shortcut and install` option to Linux version, allowing users to create a shortcut and install 
+- Added "Playing..." indicator for "Preview" button in the voice mixer.
+
+# v1.0.6
+- Added `Insert chapter marker` button in text editor to insert chapter markers at the current cursor position.
+- Added `Preview` button in voice mixer to preview the voice mix with the selected settings.
+- Fixed `f-string: unmatched '['` error in Voice preview, mentioned in #14
+- Fixed the issue with the content before first chapter not being included in the output.
+- Fixed m4b chapter generation opens CMD window in Windows.
+
+# v1.0.5
+- Added new output format: `m4b`, enabling chapter metadata in audiobooks. Special thanks to @jborza for implementing this feature in PR #10.
+- Better approach for determining the correct configuration folder for Linux and MacOS, using platformdirs. (Fixes Docker issue #12)
+- Improvements in documentation and code.
+
+# v1.0.4
+- Merge pull request [#7](https://github.com/denizsafak/abogen/pull/7) by @jborza that improves voice preview and documentation.
+- Fixed the issue when a voice is selected, the voice mixer tries to pre-select that voice and ignores existing profiles.
+- Fixed the error while renaming the default "New profile" in the voice mixer.
+- Fixed subtitle_combo enabling/disabling when a voice in the voice mixer is selected.
+- Prevented using special characters in the profile name to avoid conflicts.
+- Improved invalid profile handling in the voice mixer.
+
+# v1.0.3
+- Added voice mixing, allowing multiple voices to be combined into a single “Mixed Voice”, a feature mentioned by @PulsarFTW in #1. Special thanks to @jborza for making this possible through his contributions in #5.
+- Added profile system to voice mixer, allowing users to create and manage multiple voice profiles.
+- Improvements in the voice mixer, mostly for organizing controls and enhancing user experience.
+- Added icons for flags and genders in the GUI, making it easier to identify different options.
+- Improved the content and chapter extraction process for EPUB files, ensuring better handling of various structures.
+- Switched to platformdirs for determining the correct desktop path, instead of using old methods.
+- Fixed preview voices was not using GPU acceleration, which was causing performance issues.
+- Improvements in code and documentation.
+
+# v1.0.2
+- Enhanced EPUB handling by treating all items in chapter list (including anchors) as chapters, improving navigation and organization for poorly structured books, mentioned by @Darthagnon in #4
+- Fixed the issue with some chapters in EPUB files had missing content.
+- Fixed the issue with some EPUB files only having one chapter caused the program to ignore the entire book.
+- Fixed "utf-8' codec can't decode byte" error, mentioned by @nigelp in #3
+- Added "Replace single newlines with spaces" option in the menu. This can be useful for texts that have imaginary line breaks.
+- Improvements in code and documentation.
+
+# v1.0.1
+- Added abogen-cli command for better troubleshooting and error handling.
 - Switched from setuptools to hatchling for packaging.
 - Added classifiers to the package metadata.
-- Fixed "No module named 'docopt'" and "setuptools.build_meta" import errors while using .bat installer in Windows, mentioned by @nigelp in https://github.com/denizsafak/abogen/issues/2 
+- Fixed "No module named 'docopt'" and "setuptools.build_meta" import errors while using .bat installer in Windows, mentioned by @nigelp in #2
-- Improvements in code and documentation.
+- Improvements in code and documentation.

README.md

@@ -1,7 +1,8 @@
 # abogen <img width="40px" title="abogen icon" src="https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/abogen/assets/icon.ico" align="right" style="padding-left: 10px; padding-top:5px;">
 
 [![Build Status](https://github.com/denizsafak/abogen/actions/workflows/test_pip.yml/badge.svg)](https://github.com/denizsafak/abogen/actions)
-![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue?logo=python)
+[![GitHub Release](https://img.shields.io/github/v/release/denizsafak/abogen)](https://github.com/denizsafak/abogen/releases/latest)
+[![Abogen PyPi Python Versions](https://img.shields.io/pypi/pyversions/abogen)](https://pypi.org/project/abogen/)
 [![Operating Systems](https://img.shields.io/badge/os-windows%20%7C%20linux%20%7C%20macos%20-blue)](https://github.com/denizsafak/abogen/releases/latest)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![License: MIT](https://img.shields.io/badge/License-MIT-maroon.svg)](https://opensource.org/licenses/MIT)
@@ -13,10 +14,9 @@ Abogen is a powerful text-to-speech conversion tool that makes it easy to turn e
 ## Demo
 https://github.com/user-attachments/assets/cb66512d-0a52-48c3-bda4-f1e6a03fb8d6
 
-
 > This demo was generated in just 5 seconds, producing ∼1 minute of audio with perfectly synced subtitles. To create a similar video, see [the demo guide](https://github.com/denizsafak/abogen/tree/main/demo).
 
-## `How to install?`
+## `How to install?` <a href="https://pypi.org/project/abogen/" target="_blank"><img src="https://img.shields.io/pypi/pyversions/abogen" alt="Abogen Compatible PyPi Python Versions" align="right" style="margin-top:6px;"></a>
 ### Windows
 Go to [espeak-ng latest release](https://github.com/espeak-ng/espeak-ng/releases/latest) download and run the *.msi file.
 ```bash
@@ -55,19 +55,26 @@ sudo dnf install espeak-ng
 # Install abogen
 pip install abogen
 ```
-> If you get "No matching distribution found" error, try installing it on supported Python (3.10 to 3.12). You can use [pyenv](https://github.com/pyenv/pyenv) to manage multiple Python versions easily in Linux.
+> If you get `WARNING: The script abogen-cli is installed in '/home/username/.local/bin' which is not on PATH.` error, run the following command to add it to your PATH:
+>```bash
+>echo "export PATH=\"/home/$USER/.local/bin:\$PATH\"" >> ~/.bashrc && source ~/.bashrc
+>```
 
-Then simply run by typing:
+> If you get "No matching distribution found" error, try installing it on supported Python (3.10 to 3.12). You can use [pyenv](https://github.com/pyenv/pyenv) to manage multiple Python versions easily in Linux. Watch this [video](https://www.youtube.com/watch?v=MVyb-nI4KyI) by NetworkChuck for a quick guide.
+
+## `How to run?`
+If you installed using pip, you can simply run the following command to start Abogen:
 
 ```bash
 abogen
 ```
+> If you installed using the Windows installer `(WINDOWS_INSTALL.bat)`, It should have created a shortcut in the same folder, or your desktop. You can run it from there. If you lost the shortcut, Abogen is located in `python_embedded/Scripts/abogen.exe`. You can run it from there directly.
 
 ## `How to use?`
 1) Drag and drop any ePub, PDF, or text file (or use the built-in text editor)
 2) Configure the settings:
     - Set speech speed
-    - Select a voice
+    - Select a voice (or create a custom voice using voice mixer)
     - Select subtitle generation style (by sentence, word, etc.)
     - Select output format
     - Select where to save the output
@@ -82,19 +89,52 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 - **Supported formats**: `ePub`, `PDF`, or `.TXT` files (or use built-in text editor)
 - **Speed**: Adjust speech rate from `0.1x` to `2.0x`
 - **Voices**: First letter of the language code (e.g., `a` for American English, `b` for British English, etc.), second letter is for `m` for male and `f` for female.
+- **Voice mixer**: Create custom voices by mixing different voice models with a profile system.
 - **Generate subtitles**: `Disabled`, `Sentence`, `Sentence + Comma`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry)
-- **Output formats**: `.WAV`, `.FLAC`, or `.MP3`
+- **Output formats**: `.WAV`, `.FLAC`, `.MP3`, `.OPUS` and `M4B (with chapters)` (Special thanks to [@jborza](https://github.com/jborza) for chapter support in PR [#10](https://github.com/denizsafak/abogen/pull/10))
 - **Save location**: `Save next to input file`, `Save to desktop`, or `Choose output folder`
 - **Chapter Control**: Select specific `chapters` from ePUBs or `chapters + pages` from PDFs.
+- **Save each chapter separately**: Save each chapter in e-books as a separate audio file.
+- **Project folder**: Save the converted items in a project folder with available metadata files.
 - **Options**:
-    - **Configure max words per subtitle**: Automatically configures the maximum number of words per subtitle entry.
+    - **Replace single newlines with spaces**: Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks.
+    - **Configure max words per subtitle**: Configures the maximum number of words per subtitle entry.
     - **Create desktop shortcut**: Creates a shortcut on your desktop for easy access.
     - **Open config.json directory**: Opens the directory where the configuration file is stored.
     - **Open temp directory**: Opens the temporary directory where converted text files are stored.
-    - **Clear all teporary files**: Deletes all temporary files created during the conversion process.
+    - **Clear all temporary files**: Deletes all temporary files created during the conversion process.
     - **Check for updates at startup**: Automatically checks for updates when the program starts.
 - **After conversion**: `Open file`, `Go to folder`, `New conversion`, or `Go back`.
 
+## `Voice Mixer`
+<img title="Abogen Voice Mixer" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/voice_mixer.png'>
+
+With voice mixer, you can create custom voices by mixing different voice models. You can adjust the weight of each voice and save your custom voice as a profile for future use. The voice mixer allows you to create unique and personalized voices. (Huge thanks to [@jborza](https://github.com/jborza) for making this possible through his contributions in [#5](https://github.com/denizsafak/abogen/pull/5))
+
+## `About Chapter Markers`
+When you process ePUB or PDF files, Abogen converts them into text files stored in your temporary directory. When you click "Edit," you're actually modifying these converted text files. In these text files, you'll notice tags that look like this:
+
+```
+<<CHAPTER_MARKER:Chapter Title>>
+```
+These are chapter markers. They are automatically added when you process ePUB or PDF files, based on the chapters you select. They serve an important purpose:
+-  Allow you to split the text into separate audio files for each chapter
+-  Save time by letting you reprocess only specific chapters if errors occur, rather than the entire file
+
+You can manually add these markers to plain text files for the same benefits. Simply include them in your text like this:
+
+```
+<<CHAPTER_MARKER:Introduction>>
+This is the beginning of my text...  
+
+<<CHAPTER_MARKER:Main Content>> 
+Here's another part...  
+```
+When you process the text file, Abogen will detect these markers automatically and ask if you want to save each chapter separately and create a merged version.
+
+![Abogen Chapter Marker](https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/chapter_marker.png)
+
+
 ## `Supported Languages`
 ```
 # 🇺🇸 'a' => American English, 🇬🇧 'b' => British English
@@ -116,8 +156,49 @@ keep-open=yes
 --audio-device=openal
 --sub-margin-x=235
 --sub-pos=60
+# --- Audio Quality ---
+audio-spdif=ac3,dts,eac3,truehd,dts-hd
+audio-channels=auto
+audio-samplerate=48000
+volume-max=200
 ```
 
+## `Docker Guide`
+If you want to run Abogen in a Docker container:
+1) [Download the repository](https://github.com/denizsafak/abogen/archive/refs/heads/main.zip) and extract, or clone it using git.
+2) Go to `abogen` folder. You should see `Dockerfile` there.
+3) Open your termminal in that directory and run the following commands:
+
+```bash
+# Build the Docker image:
+docker build --progress plain -t abogen .
+
+# Note that building the image may take a while.
+# After building is complete, run the Docker container:
+
+# Windows
+docker run --name abogen -v %cd%:/shared -p 5800:5800 -p 5900:5900 --gpus all abogen
+
+# Linux
+docker run --name abogen -v $(pwd):/shared -p 5800:5800 -p 5900:5900 --gpus all abogen
+
+# MacOS
+docker run --name abogen -v $(pwd):/shared -p 5800:5800 -p 5900:5900 abogen
+
+# We expose port 5800 for use by a web browser, 5900 if you want to connect with a VNC client.
+```
+
+Abogen launches automatically inside the container. 
+- You can access it via a web browser at [http://localhost:5800](http://localhost:5800) or connect to it using a VNC client at `localhost:5900`.
+- You can use `/shared` directory to share files between your host and the container.
+- For later use, start it with `docker start abogen` and stop it with `docker stop abogen`.
+
+Known issues:
+- Audio preview is not working inside container (ALSA error).
+- `Open temp directory` and `Open configuration directory` options in settings not working. (Tried pcmanfm, did not work with Abogen).
+
+(Special thanks to [@geo38](https://www.reddit.com/user/geo38/) from Reddit, who provided the Dockerfile and instructions in [this comment](https://www.reddit.com/r/selfhosted/comments/1k8x1yo/comment/mpe0bz8/).)
+
 ## `Similar Projects`
 Abogen is a standalone project, but it is inspired by and shares some similarities with other projects. Here are a few:
 - [audiblez](https://github.com/santinic/audiblez): Generate audiobooks from e-books. **(Has CLI and GUI support)**
@@ -126,11 +207,11 @@ Abogen is a standalone project, but it is inspired by and shares some similariti
 - [epub_to_audiobook](https://github.com/p0n1/epub_to_audiobook): EPUB to audiobook converter, optimized for Audiobookshelf
 
 ## `Roadmap`
-- [ ] Improve PDF support for better text extraction.
+- [ ] Add OCR scan feature for PDF files using docling.
-- [ ] Add chapter metadata for .m4a files using ffmpeg-bin.
+- [x] Add chapter metadata for .m4a files. (Issue [#9](https://github.com/denizsafak/abogen/issues/9), PR [#10](https://github.com/denizsafak/abogen/pull/10))
 - [ ] Add support for different languages in GUI.
-- [ ] Add voice formula feature that enables mixing different voice models. https://github.com/denizsafak/abogen/issues/1
+- [x] Add voice formula feature that enables mixing different voice models. (Issue [#1](https://github.com/denizsafak/abogen/issues/1), PR [#5](https://github.com/denizsafak/abogen/pull/5))
-- [ ] Add support for kokoro-onnx.
+- [ ] Add support for kokoro-onnx (If it's necessary).
 - [ ] Add dark mode.
 
 ## `Troubleshooting`
@@ -147,7 +228,8 @@ If you'd like to modify the code and contribute to development, you can [downloa
 ```bash
 # Go to the directory where you extracted the repository and run:
 pip install -e .      # Installs the package in editable mode
-python -m build       # Builds the package in dist folder
+pip install build     # Install the build package
+python -m build       # Builds the package in dist folder (optional)
 abogen                # Opens the GUI
 ```
 Feel free to explore the code and make any changes you like.
@@ -155,7 +237,9 @@ Feel free to explore the code and make any changes you like.
 ## `Credits`
 - Abogen uses [Kokoro](https://github.com/hexgrad/kokoro) for its high-quality, natural-sounding text-to-speech synthesis. Huge thanks to the Kokoro team for making this possible.
 - Thanks to [@wojiushixiaobai](https://github.com/wojiushixiaobai) for [Embedded Python](https://github.com/wojiushixiaobai/Python-Embed-Win64) packages. These modified packages include pip pre-installed, enabling Abogen to function as a standalone application without requiring users to separately install Python in Windows.
+- Thanks to creators of [EbookLib](https://github.com/aerkalov/ebooklib), a Python library for reading and writing ePub files, which is used for extracting text from ePub files.
 - Special thanks to the [PyQt](https://www.riverbankcomputing.com/software/pyqt/) team for providing the cross-platform GUI toolkit that powers Abogen's interface.
+- Icons: [US](https://icons8.com/icon/aRiu1GGi6Aoe/usa), [Great Britain](https://icons8.com/icon/t3NE3BsOAQwq/great-britain), [Spain](https://icons8.com/icon/ly7tzANRt33n/spain), [France](https://icons8.com/icon/3muzEmi4dpD5/france), [India](https://icons8.com/icon/esGVrxg9VCJ1/india), [Italy](https://icons8.com/icon/PW8KZnP7qXzO/italy), [Japan](https://icons8.com/icon/McQbrq9qaQye/japan), [Brazil](https://icons8.com/icon/zHmH8HpOmM90/brazil), [China](https://icons8.com/icon/Ej50Oe3crXwF/china), [Female](https://icons8.com/icon/uI49hxbpxTkp/female), [Male](https://icons8.com/icon/12351/male) and [Voice Id](https://icons8.com/icon/GskSeVoroQ7u/voice-id) icons by [Icons8](https://icons8.com/).
 
 ## `License`
 This project is available under the MIT License - see the [LICENSE](https://github.com/denizsafak/abogen/blob/main/LICENSE) file for details.

WINDOWS_INSTALL.bat

@@ -46,8 +46,7 @@ if exist "%VERSION_FILE%" (
     set "LOCAL_VERSION_CLEAN=!LOCAL_VERSION:.=!"
 
     :: First verify GitHub is accessible by checking HTTP status code
-    curl -s -o nul -w "%%{http_code}" "%VERSION_URL%" > "%TEMP%\abogen_http_status.txt"
+    for /f %%i in ('curl -s -o nul -w "%%{http_code}" "%VERSION_URL%"') do set abogen_http_status=%%i
-    set /p abogen_http_status=<"%TEMP%\abogen_http_status.txt"
     
     if not "!abogen_http_status!"=="200" (
         echo Failed to access GitHub repository ^(HTTP status: !abogen_http_status!^). Continuing with current version.
@@ -55,14 +54,8 @@ if exist "%VERSION_FILE%" (
     )
     
     :: Get the remote version (only if GitHub is accessible)
-    curl -s -o "%TEMP%\abogen_remote_version.txt" "%VERSION_URL%"
+    for /f "delims=" %%i in ('curl -s "%VERSION_URL%"') do set abogen_remote_version=%%i
-    findstr "^" "%TEMP%\abogen_remote_version.txt" >nul 2>&1
-    if errorlevel 1 (
-        echo Failed to retrieve version information. Continuing with current version.
-        goto continue_with_current_version
-    )
     
-    set /p abogen_remote_version=<"%TEMP%\abogen_remote_version.txt"
     if "!abogen_remote_version!"=="" (
         echo Empty version information received. Continuing with current version.
         goto continue_with_current_version
@@ -97,8 +90,7 @@ if exist "%VERSION_FILE%" (
         echo Downloading the latest update...
         
         :: Test the zip URL before downloading
-        curl -s -o nul -w "%%{http_code}" "%UPDATE_ZIP_URL%" > "%TEMP%\abogen_zip_status.txt"
+        for /f %%i in ('curl -s -o nul -w "%%{http_code}" "%UPDATE_ZIP_URL%"') do set abogen_zip_status=%%i
-        set /p abogen_zip_status=<"%TEMP%\abogen_zip_status.txt"
         
         if not "!abogen_zip_status!"=="302" (
             echo Failed to access update zip file ^(HTTP status: !abogen_zip_status!^). Continuing with current version.
@@ -137,7 +129,7 @@ if exist "%VERSION_FILE%" (
         )
     ) else (
         echo Current version: !LOCAL_VERSION!, Remote version: !abogen_remote_version!
-        echo You are usering the latest version.
+        echo You are using the latest version.
     )
 ) else (
     echo VERSION file not found. Cannot check for updates.
@@ -227,6 +219,15 @@ if errorlevel 1 (
     exit /b
 )
 
+:: Install progress's fixed version
+echo Installing fixed version of progress...
+%PYTHON_CONSOLE_PATH% -m pip install --force-reinstall https://github.com/denizsafak/abogen/raw/refs/heads/main/abogen/resources/progress-1.6-py3-none-any.whl --no-warn-script-location
+if errorlevel 1 (
+    echo Failed to install fixed version of progress.
+    pause
+    exit /b
+)
+
 :: Install setup requirements
 echo Installing setup requirements...
 %PYTHON_CONSOLE_PATH% -m pip install --upgrade setuptools wheel sphinx hatchling --no-warn-script-location

abogen/Dockerfile

@@ -0,0 +1,42 @@
+# Special thanks to @geo38 from Reddit, who provided this Dockerfile:
+# https://www.reddit.com/r/selfhosted/comments/1k8x1yo/comment/mpe0bz8/
+
+# Use a docker base image that runs a window manager that can be viewed
+# outside the image with a web browser or VNC client.
+# https://github.com/jlesage/docker-baseimage-gui
+FROM jlesage/baseimage-gui:debian-12-v4
+
+# Load stuff needed by abogen
+RUN apt-get update \
+ && apt-get install -y \
+        python3 \
+        python3-venv \
+        python3-pip \
+        python3-pyqt5 \
+        espeak-ng \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
+
+# The base image will run /startapp.sh on launch.
+#
+# The base image runs that script as user 'app' uid=1000. That user
+# does not exist in the base image but is created at run time.
+#
+# We need to install abogen in python venv (requirement of newer python3).
+#
+# The python venv has to be writable by the 'app' user as abogen dynamically
+# installs python packages, so create the venv as that user
+#
+# We intend to share the /shared directory with the host using a bind volume
+# in order to access any source files and the created files.
+
+RUN echo '#!/bin/bash\nsource /app/venv/bin/activate\nexec abogen' > /startapp.sh \
+  && chmod 555 /startapp.sh \
+  && mkdir /app /shared \
+  && chown 1000:1000 /app /shared \
+  && chmod 755 /app /shared
+USER 1000:1000
+RUN python3 -m venv /app/venv
+RUN /bin/bash -c "source /app/venv/bin/activate && pip install abogen"
+# Change back to user ROOT as the startup scripts inside base image needs it
+USER root

abogen/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.7

abogen/constants.py

@@ -1,4 +1,4 @@
-from utils import get_version, get_user_config_path
+from utils import get_version
 
 # Program Information
 PROGRAM_NAME = "abogen"
@@ -102,16 +102,3 @@ SAMPLE_VOICE_TEXTS = {
     "p": "Este é um exemplo da voz selecionada.",
     "z": "这是所选语音的示例。",
 }
-
-# flags mapping for voice display
-FLAGS = {
-    "a": "🇺🇸",
-    "b": "🇬🇧",
-    "e": "🇪🇸",
-    "f": "🇫🇷",
-    "h": "🇮🇳",
-    "i": "🇮🇹",
-    "j": "🇯🇵",
-    "p": "🇧🇷",
-    "z": "🇨🇳",
-}

abogen/conversion.py

@@ -2,17 +2,40 @@ import os
 import re
 import tempfile
 import time
+import chardet
+import charset_normalizer
+from platformdirs import user_desktop_dir
 from PyQt5.QtCore import QThread, pyqtSignal, Qt
 from PyQt5.QtWidgets import QCheckBox, QVBoxLayout, QDialog, QLabel, QDialogButtonBox
 import soundfile as sf
-from utils import clean_text
+from utils import clean_text, create_process
 from constants import PROGRAM_NAME, LANGUAGE_DESCRIPTIONS, SAMPLE_VOICE_TEXTS
+from voice_formulas import get_new_voice
+import static_ffmpeg
+import threading  # for efficient waiting
+import subprocess
 
 
 def get_sample_voice_text(lang_code):
     return SAMPLE_VOICE_TEXTS.get(lang_code, SAMPLE_VOICE_TEXTS["a"])
 
 
+def detect_encoding(file_path):
+    with open(file_path, "rb") as f:
+        raw_data = f.read()
+    detected_encoding = None
+    for detectors in (charset_normalizer, chardet):
+        try:
+            result = detectors.detect(raw_data)["encoding"]
+        except Exception:
+            continue
+        if result is not None:
+            detected_encoding = result
+            break
+    encoding = detected_encoding if detected_encoding else "utf-8"
+    return encoding.lower()
+
+
 class ChapterOptionsDialog(QDialog):
     def __init__(self, chapter_count, parent=None):
         super().__init__(parent)
@@ -108,6 +131,7 @@ class ConversionThread(QThread):
         use_gpu=True,
     ):  # Add use_gpu parameter
         super().__init__()
+        self._chapter_options_event = threading.Event()
         self.np = np_module
         self.KPipeline = kpipeline_class
         self.file_name = file_name
@@ -132,6 +156,9 @@ class ConversionThread(QThread):
         self.max_subtitle_words = 50  # Default value, will be overridden from GUI
 
     def run(self):
+        print(
+            f"\nVoice: {self.voice}\nLanguage: {self.lang_code}\nSpeed: {self.speed}\nGPU: {self.use_gpu}\nFile: {self.file_name}\nSubtitle mode: {self.subtitle_mode}\nOutput format: {self.output_format}\nSave option: {self.save_option}\n"
+        )
         try:
             # Show configuration
             self.log_updated.emit("Configuration:")
@@ -153,6 +180,8 @@ class ConversionThread(QThread):
             self.log_updated.emit(f"- Subtitle mode: {self.subtitle_mode}")
             self.log_updated.emit(f"- Output format: {self.output_format}")
             self.log_updated.emit(f"- Save option: {self.save_option}")
+            if self.replace_single_newlines:
+                self.log_updated.emit(f"- Replace single newlines: Yes")
 
             # Display save_chapters_separately flag if it's set
             if hasattr(self, "save_chapters_separately"):
@@ -183,7 +212,10 @@ class ConversionThread(QThread):
             if self.is_direct_text:
                 text = self.file_name  # Treat file_name as direct text input
             else:
-                with open(self.file_name, "r", encoding="utf-8") as file:
+                encoding = detect_encoding(self.file_name)
+                with open(
+                    self.file_name, "r", encoding=encoding, errors="replace"
+                ) as file:
                     text = file.read()
 
             # Clean up text using utility function
@@ -194,6 +226,12 @@ class ConversionThread(QThread):
             chapter_splits = list(re.finditer(chapter_pattern, text))
             chapters = []
             if chapter_splits:
+                # prepend Introduction for content before first marker
+                first_start = chapter_splits[0].start()
+                if first_start > 0:
+                    intro_text = text[:first_start].strip()
+                    if intro_text:
+                        chapters.append(("Introduction", intro_text))
                 for idx, match in enumerate(chapter_splits):
                     start = match.end()
                     end = (
@@ -224,18 +262,12 @@ class ConversionThread(QThread):
                 and not self.chapter_options_set
             ):
 
-                self.waiting_for_user_input = True
+                # Emit signal to main thread and wait
-                # Emit signal to main thread to show dialog
                 self.chapters_detected.emit(total_chapters)
-
+                self._chapter_options_event.wait()
-                # Wait for chapter options to be set
-                while self.waiting_for_user_input and not self.cancel_requested:
-                    time.sleep(0.1)
-
                 if self.cancel_requested:
                     self.conversion_finished.emit("Cancelled", None)
                     return
-
                 self.chapter_options_set = True
 
             # Log all detected chapters at the beginning
@@ -256,11 +288,19 @@ class ConversionThread(QThread):
             base_path = self.display_path if self.display_path else self.file_name
             base_name = os.path.splitext(os.path.basename(base_path))[0]
             if self.save_option == "Save to Desktop":
-                parent_dir = os.path.join(os.path.expanduser("~"), "Desktop")
+                parent_dir = user_desktop_dir()
             elif self.save_option == "Save next to input file":
                 parent_dir = os.path.dirname(base_path)
             else:
                 parent_dir = self.output_folder or os.getcwd()
+            # Ensure the output folder exists, error if it doesn't
+            if not os.path.exists(parent_dir):
+                self.log_updated.emit(
+                    (
+                        f"Output folder does not exist: {parent_dir}",
+                        "red",
+                    )
+                )
             # Find a unique suffix for both folder and merged file, always
             counter = 1
             while True:
@@ -303,6 +343,12 @@ class ConversionThread(QThread):
             # Initialize current segment counter
             current_segment = 0
 
+            # Initialize chapter times
+            chapters_time = [
+                {"chapter": chapter[0], "start": 0.0, "end": 0.0}
+                for chapter in chapters
+            ]
+
             # Instead of processing the whole text, process by chapter
             for chapter_idx, (chapter_name, chapter_text) in enumerate(chapters, 1):
                 if total_chapters > 1:
@@ -318,11 +364,22 @@ class ConversionThread(QThread):
                 chapter_subtitle_entries = []
                 chapter_current_time = 0.0
 
+                # chapter start time
+                chapter_time = chapters_time[chapter_idx - 1]
+                chapter_time["start"] = current_time
+
                 # Set split_pattern to \n+ which will split on one or more newlines
                 split_pattern = r"\n+"
+
+                # 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
+
                 for result in tts(
                     chapter_text,
-                    voice=self.voice,
+                    voice=loaded_voice,
                     speed=self.speed,
                     split_pattern=split_pattern,
                 ):
@@ -424,6 +481,9 @@ class ConversionThread(QThread):
                     # Update progress more frequently (after each result)
                     self.progress_updated.emit(percent, etr_str)
 
+                # Update chapter end time
+                chapter_time["end"] = current_time
+
                 # Save the individual chapter output if save_chapters_separately is enabled
                 if (
                     save_chapters_separately
@@ -440,22 +500,54 @@ class ConversionThread(QThread):
 
                     # Concatenate chapter audio and save
                     chapter_audio = self.np.concatenate(chapter_audio_segments)
+                    # Determine chapter extension (.wav for m4b output)
+                    chapter_ext = 'wav' if self.output_format == 'm4b' else self.output_format
                     chapter_out_path = os.path.join(
-                        chapters_out_dir, f"{chapter_filename}.{self.output_format}"
+                        chapters_out_dir, f"{chapter_filename}.{chapter_ext}"
-                    )
-                    sf.write(
-                        chapter_out_path,
-                        chapter_audio,
-                        24000,
-                        format=self.output_format,
                     )
+                    if self.output_format == "opus":
+                        static_ffmpeg.add_paths()
+                        proc = create_process(
+                            [
+                                "ffmpeg",
+                                "-y",
+                                "-thread_queue_size", "1024", # Increased thread_queue_size for chapter opus
+                                "-f",
+                                "f32le",
+                                "-ar",
+                                "24000",
+                                "-ac",
+                                "1",
+                                "-i",
+                                "pipe:0",
+                                "-c:a",
+                                "libopus",
+                                "-b:a",
+                                "24000",
+                                chapter_out_path,
+                            ],
+                            stdin=subprocess.PIPE,
+                            text=False  # Ensure binary stdin for audio data
+                        )
+                        proc.stdin.write(chapter_audio.astype("float32").tobytes())
+                        proc.stdin.close()
+                        proc.wait()
+                    else:
+                        sf.write(
+                            chapter_out_path,
+                            chapter_audio,
+                            24000,
+                            format='wav' if self.output_format == 'm4b' else self.output_format,
+                        )
 
                     # Generate .srt subtitle file for chapter if not Disabled
                     if self.subtitle_mode != "Disabled" and chapter_subtitle_entries:
                         chapter_srt_path = os.path.join(
                             chapters_out_dir, f"{chapter_filename}.srt"
                         )
-                        with open(chapter_srt_path, "w", encoding="utf-8") as srt_file:
+                        with open(
+                            chapter_srt_path, "w", encoding="utf-8", errors="replace"
+                        ) as srt_file:
                             for i, (start, end, text) in enumerate(
                                 chapter_subtitle_entries, 1
                             ):
@@ -486,32 +578,74 @@ class ConversionThread(QThread):
                 or not self.save_chapters_separately
                 or getattr(self, "merge_chapters_at_end", True)
             )
+            
+            intended_output_format = self.output_format # Store the original choice
+
             if audio_segments and merge_chapters:
                 self.log_updated.emit("\nFinalizing audio file...\n")
-                audio = self.np.concatenate(audio_segments)
+                audio_data_np = self.np.concatenate(audio_segments)
+                
                 out_dir = parent_dir
-                # Use the same suffix as above
+                base_filepath_no_ext = os.path.join(out_dir, f"{base_name}{suffix}")
-                out_filename = f"{base_name}{suffix}.{self.output_format}"
+
-                out_path = os.path.join(out_dir, out_filename)
+                final_out_path = None
-                srt_path = os.path.splitext(out_path)[0] + ".srt"
+
-                sf.write(out_path, audio, 24000, format=self.output_format)
+                if intended_output_format == "m4b":
-                if self.subtitle_mode != "Disabled":
+                    final_out_path = self._generate_m4b_with_chapters(audio_data_np, chapters_time, base_filepath_no_ext)
-                    with open(srt_path, "w", encoding="utf-8") as srt_file:
+                elif intended_output_format == "opus":
-                        for i, (start, end, text) in enumerate(subtitle_entries, 1):
+                    static_ffmpeg.add_paths()
-                            srt_file.write(
+                    opus_out_path = f"{base_filepath_no_ext}.opus"
-                                f"{i}\n{self._srt_time(start)} --> {self._srt_time(end)}\n{text}\n\n"
+                    ffmpeg_cmd_opus = [
-                            )
+                        "ffmpeg", "-y",
-                    self.conversion_finished.emit(
+                        "-thread_queue_size", "1024", # Increased thread_queue_size
-                        (
+                        "-f", "f32le", "-ar", "24000", "-ac", "1", "-i", "pipe:0",
-                            f"Audiobook saved to: {out_path}\n\nSubtitle saved to: {srt_path}",
+                        "-c:a", "libopus", "-b:a", "24000", # Original bitrate
-                            "green",
+                        opus_out_path,
-                        ),
+                    ]
-                        out_path,
+                    try:
-                    )
+                        process = create_process(ffmpeg_cmd_opus, stdin=subprocess.PIPE, text=False)  # Ensure binary stdin
+                        process.stdin.write(audio_data_np.astype("float32").tobytes())
+                        process.stdin.close()
+                        if process.wait() == 0:
+                            final_out_path = opus_out_path
+                        else:
+                            self.log_updated.emit(("Opus conversion failed.", "red"))
+                            final_out_path = None 
+                    except Exception as e_opus:
+                        self.log_updated.emit((f"Error during Opus conversion: {str(e_opus)}", "red"))
+                        final_out_path = None
+                else: # For other formats like wav
+                    standard_out_path = f"{base_filepath_no_ext}.{intended_output_format}"
+                    try:
+                        sf.write(standard_out_path, audio_data_np, 24000, format=intended_output_format)
+                        final_out_path = standard_out_path
+                    except Exception as e_sf:
+                        self.log_updated.emit((f"Failed to write audio file {standard_out_path}: {str(e_sf)}", "red"))
+                        final_out_path = None
+
+                # Subtitle and final message logic
+                if final_out_path:
+                    if self.subtitle_mode != "Disabled":
+                        srt_path = os.path.splitext(final_out_path)[0] + ".srt"
+                        with open(srt_path, "w", encoding="utf-8", errors="replace") as srt_file:
+                            for i, (start, end, text) in enumerate(subtitle_entries, 1):
+                                srt_file.write(
+                                    f"{i}\n{self._srt_time(start)} --> {self._srt_time(end)}\n{text}\n\n"
+                                )
+                        self.conversion_finished.emit(
+                            (
+                                f"Audiobook saved to: {final_out_path}\n\nSubtitle saved to: {srt_path}",
+                                "green",
+                            ),
+                            final_out_path,
+                        )
+                    else:
+                        self.conversion_finished.emit(
+                            (f"Audiobook saved to: {final_out_path}", "green"), final_out_path
+                        )
                 else:
-                    self.conversion_finished.emit(
+                    self.log_updated.emit(("Audio generation failed (final_out_path was not set).", "red"))
-                        (f"Audiobook saved to: {out_path}", "green"), out_path
+                    self.conversion_finished.emit(("Audio generation failed.", "red"), None)
-                    )
             elif audio_segments and not merge_chapters:
                 self.conversion_finished.emit(
                     (
@@ -532,6 +666,81 @@ class ConversionThread(QThread):
         self.save_chapters_separately = options["save_chapters_separately"]
         self.merge_chapters_at_end = options["merge_chapters_at_end"]
         self.waiting_for_user_input = False
+        self._chapter_options_event.set()
+
+    def _generate_m4b_with_chapters(self, audio_data_np, chapters_time, base_filepath_no_ext):
+        final_wav_path = f"{base_filepath_no_ext}.wav"
+        
+        if not chapters_time or len(chapters_time) <= 1:
+            self.log_updated.emit(
+                (
+                    "File contains only one chapter or no chapters were detected. Audio will be saved as a standard .wav file instead.\n",
+                    "red",
+                )
+            )
+            try:
+                sf.write(final_wav_path, audio_data_np, 24000, format="wav")
+                return final_wav_path
+            except Exception as e_wav_single:
+                self.log_updated.emit((f"Failed to save single/no chapter audio as WAV: {str(e_wav_single)}", "red"))
+                return None
+
+        output_m4b_path = f"{base_filepath_no_ext}.m4b"
+        chapters_info_path = f"{base_filepath_no_ext}_chapters.txt"
+
+        try:
+            with open(chapters_info_path, "w", encoding="utf-8") as f:
+                f.write(";FFMETADATA1\n")
+                for chapter in chapters_time:
+                    f.write(f"[CHAPTER]\n")
+                    f.write(f"TIMEBASE=1/1000\n") # Using milliseconds for precision
+                    f.write(f"START={int(chapter['start']*1000)}\n")
+                    f.write(f"END={int(chapter['end']*1000)}\n")
+                    f.write(f"title={chapter['chapter']}\n\n")
+
+            static_ffmpeg.add_paths()
+            ffmpeg_cmd = [
+                "ffmpeg", "-y",
+                "-thread_queue_size", "1024", # Increased thread_queue_size
+                "-f", "f32le", "-ar", "24000", "-ac", "1", "-i", "pipe:0",
+                "-i", chapters_info_path,
+                "-map", "0:a",
+                "-map_metadata", "1", 
+                "-map_chapters", "1",
+                "-c:a", "aac", "-b:a", "128k", # Explicitly AAC with a common bitrate
+                output_m4b_path,
+            ]
+
+            self.log_updated.emit(f"Generating audio with chapters...\n")
+
+            process = create_process(ffmpeg_cmd, stdin=subprocess.PIPE, text=False)  # Ensure binary stdin
+            process.stdin.write(audio_data_np.astype("float32").tobytes())
+            process.stdin.close()
+            return_code = process.wait()
+
+            if return_code == 0:
+                return output_m4b_path
+            else:
+                self.log_updated.emit(
+                    (f"FFmpeg failed to create M4B (return code {return_code}).\n\nFalling back to WAV.\n", "red")
+                )
+                sf.write(final_wav_path, audio_data_np, 24000, format="wav")
+                return final_wav_path
+
+        except Exception as e:
+            self.log_updated.emit((f"Error during M4B generation: {str(e)}.\n\nFalling back to WAV.\n", "red"))
+            try:
+                sf.write(final_wav_path, audio_data_np, 24000, format="wav")
+                return final_wav_path
+            except Exception as e_wav_fallback:
+                self.log_updated.emit((f"Critical error: Failed to save fallback WAV: {str(e_wav_fallback)}\n", "red"))
+                return None
+        finally:
+            if os.path.exists(chapters_info_path):
+                try:
+                    os.remove(chapters_info_path)
+                except Exception as e_clean:
+                    self.log_updated.emit((f"Warning: Could not delete temporary chapter file {chapters_info_path}: {e_clean}", "orange"))
 
     def _srt_time(self, t):
         """Helper function to format time for SRT files"""
@@ -639,7 +848,14 @@ class VoicePreviewThread(QThread):
     error = pyqtSignal(str)
 
     def __init__(
-        self, np_module, kpipeline_class, lang_code, voice, speed, parent=None
+        self,
+        np_module,
+        kpipeline_class,
+        lang_code,
+        voice,
+        speed,
+        use_gpu=False,
+        parent=None,
     ):
         super().__init__(parent)
         self.np_module = np_module
@@ -647,17 +863,26 @@ class VoicePreviewThread(QThread):
         self.lang_code = lang_code
         self.voice = voice
         self.speed = speed
-        self.temp_wav = None
+        self.use_gpu = use_gpu
 
     def run(self):
+        print(
+            f"\nVoice: {self.voice}\nLanguage: {self.lang_code}\nSpeed: {self.speed}\nGPU: {self.use_gpu}\n"
+        )
         try:
+            device = "cuda" if self.use_gpu else "cpu"
             tts = self.kpipeline_class(
-                lang_code=self.lang_code, repo_id="hexgrad/Kokoro-82M"
+                lang_code=self.lang_code, repo_id="hexgrad/Kokoro-82M", device=device
             )
+            # Enable voice formula support for preview
+            if "*" in self.voice:
+                loaded_voice = get_new_voice(tts, self.voice, self.use_gpu)
+            else:
+                loaded_voice = self.voice
             sample_text = get_sample_voice_text(self.lang_code)
             audio_segments = []
             for result in tts(
-                sample_text, voice=self.voice, speed=self.speed, split_pattern=None
+                sample_text, voice=loaded_voice, speed=self.speed, split_pattern=None
             ):
                 audio_segments.append(result.audio)
             if audio_segments:

abogen/gui.py

@@ -3,6 +3,7 @@ import time
 import tempfile
 import platform
 import base64
+import re
 from PyQt5.QtWidgets import (
     QApplication,
     QWidget,
@@ -65,11 +66,12 @@ from constants import (
     GITHUB_URL,
     PROGRAM_DESCRIPTION,
     LANGUAGE_DESCRIPTIONS,
-    FLAGS,
     VOICES_INTERNAL,
     SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
 )
 from threading import Thread
+from voice_formula_gui import VoiceFormulaDialog
+from voice_profiles import load_profiles
 
 # Import ctypes for Windows-specific taskbar icon
 if platform.system() == "Windows":
@@ -126,6 +128,13 @@ class InputBox(QLabel):
         self.edit_btn.clicked.connect(self.on_edit_clicked)
         self.edit_btn.hide()
 
+        # Add Go to folder button
+        self.go_to_folder_btn = QPushButton("Go to folder", self)
+        self.go_to_folder_btn.setStyleSheet("QPushButton { padding: 6px 10px; }")
+        self.go_to_folder_btn.setToolTip("Open the folder that contains the converted file")
+        self.go_to_folder_btn.clicked.connect(self.on_go_to_folder_clicked)
+        self.go_to_folder_btn.hide()
+
     def resizeEvent(self, event):
         super().resizeEvent(event)
         margin = 12
@@ -136,6 +145,11 @@ class InputBox(QLabel):
         # Position textbox button at top left
         self.textbox_btn.move(margin, margin)
         self.edit_btn.move(margin, margin)
+        # Position go to folder button at bottom right
+        self.go_to_folder_btn.move(
+            self.width() - self.go_to_folder_btn.width(),
+            self.height() - self.go_to_folder_btn.height() - margin,
+        )
 
     def set_file_info(self, file_path):
         # get icon without resizing using custom provider
@@ -225,6 +239,7 @@ class InputBox(QLabel):
             should_show_edit = True
 
         self.edit_btn.setVisible(should_show_edit)
+        self.go_to_folder_btn.show()
 
     def set_error(self, message):
         self.setText(message)
@@ -247,6 +262,7 @@ class InputBox(QLabel):
         # Show textbox and hide edit when input is cleared
         self.textbox_btn.show()
         self.edit_btn.hide()
+        self.go_to_folder_btn.hide()
 
     def _human_readable_size(self, size, decimal_places=2):
         for unit in ["B", "KB", "MB", "GB", "TB"]:
@@ -287,8 +303,8 @@ class InputBox(QLabel):
                 )
                 win.selected_book_path = file_path
                 win.open_book_file(
-                    file_path
+                    file_path  # This will handle the dialog and setting file info
-                )  # This will handle the dialog and setting file info
+                )
                 event.acceptProposedAction()
             else:
                 self.set_error("Please drop a .txt, .epub, or .pdf file.")
@@ -317,6 +333,17 @@ class InputBox(QLabel):
             # For regular txt files
             win.open_textbox_dialog()
 
+    def on_go_to_folder_clicked(self):
+        win = self.window()
+        # win.selected_file holds the path to the text that is converted.
+        file_to_check = win.selected_file
+        
+        if file_to_check and os.path.exists(file_to_check) and os.path.isfile(file_to_check):
+            folder_path = os.path.dirname(file_to_check)
+            QDesktopServices.openUrl(QUrl.fromLocalFile(folder_path))
+        else:
+            QMessageBox.warning(win, "Error", "Converted file not found.")
+
 
 class TextboxDialog(QDialog):
     def __init__(self, parent=None):
@@ -325,7 +352,7 @@ class TextboxDialog(QDialog):
         self.setWindowFlags(
             Qt.Window | Qt.WindowCloseButtonHint | Qt.WindowMaximizeButtonHint
         )
-        self.resize(600, 400)
+        self.resize(700, 500)
 
         layout = QVBoxLayout(self)
 
@@ -355,6 +382,11 @@ class TextboxDialog(QDialog):
         self.save_as_button.clicked.connect(self.save_as_text)
         self.save_as_button.setToolTip("Save the current text to a file")
 
+        self.insert_chapter_btn = QPushButton("Insert Chapter Marker", self)
+        self.insert_chapter_btn.setToolTip("Insert a chapter marker at the cursor")
+        self.insert_chapter_btn.clicked.connect(self.insert_chapter_marker)
+        button_layout.addWidget(self.insert_chapter_btn)
+
         self.cancel_button = QPushButton("Cancel", self)
         self.cancel_button.clicked.connect(self.reject)
 
@@ -379,8 +411,14 @@ class TextboxDialog(QDialog):
         return self.text_edit.toPlainText()
 
     def handle_ok(self):
+        text = self.text_edit.toPlainText()
+        # Check if text is empty based on character count
+        if calculate_text_length(text) == 0:
+            QMessageBox.warning(self, "Textbox Error", "Text cannot be empty.")
+            return
+
         # If the text hasn't changed, treat as cancel
-        if self.text_edit.toPlainText() == self.original_text:
+        if text == self.original_text:
             self.reject()
         else:
             # Check if we need to warn about overwriting a non-temporary file
@@ -441,6 +479,14 @@ class TextboxDialog(QDialog):
         except Exception as e:
             QMessageBox.critical(self, "Save Error", f"Could not save file:\n{e}")
 
+    def insert_chapter_marker(self):
+        # Insert a fixed chapter marker without prompting
+        cursor = self.text_edit.textCursor()
+        cursor.insertText("<<CHAPTER_MARKER:Title>>")
+        self.text_edit.setTextCursor(cursor)
+        self.update_char_count()
+        self.text_edit.setFocus()
+
 
 class abogen(QWidget):
     def __init__(self):
@@ -456,8 +502,17 @@ class abogen(QWidget):
         self.selected_chapters = set()
         self.last_opened_book_path = None  # Track the last opened book path
         self.last_output_path = None
-        self.selected_voice = self.config.get("selected_voice", "af_heart")
+        # Only one of selected_profile_name or selected_voice should be set
-        self.selected_lang = self.selected_voice[0]
+        self.selected_profile_name = self.config.get("selected_profile_name")
+        self.selected_voice = None
+        self.selected_lang = None
+        self.mixed_voice_state = None
+        if self.selected_profile_name:
+            self.selected_voice = None
+            self.selected_lang = None
+        else:
+            self.selected_voice = self.config.get("selected_voice", "af_heart")
+            self.selected_lang = self.selected_voice[0] if self.selected_voice else None
         self.is_converting = False
         self.subtitle_mode = self.config.get("subtitle_mode", "Sentence")
         self.max_subtitle_words = self.config.get(
@@ -465,8 +520,9 @@ class abogen(QWidget):
         )  # Default max words per subtitle
         self.selected_format = self.config.get("selected_format", "wav")
         self.use_gpu = self.config.get(
-            "use_gpu", True
+            "use_gpu", True  # Load GPU setting with default True
-        )  # Load GPU setting with default True
+        )
+        self.replace_single_newlines = self.config.get("replace_single_newlines", False)
         self._pending_close_event = None
         self.gpu_ok = False  # Initialize GPU availability status
 
@@ -485,17 +541,32 @@ class abogen(QWidget):
         self.initUI()
         self.speed_slider.setValue(int(self.config.get("speed", 1.00) * 100))
         self.update_speed_label()
-        idx = self.voice_combo.findData(self.selected_voice)
+        # Set initial selection: prefer profile, else voice
+        idx = -1
+        if self.selected_profile_name:
+            idx = self.voice_combo.findData(f"profile:{self.selected_profile_name}")
+        elif self.selected_voice:
+            idx = self.voice_combo.findData(self.selected_voice)
         if idx >= 0:
             self.voice_combo.setCurrentIndex(idx)
+            # If a profile is selected at startup, load voices and language
+            if self.selected_profile_name:
+                from voice_profiles import load_profiles
+
+                entry = load_profiles().get(self.selected_profile_name, {})
+                if isinstance(entry, dict):
+                    self.mixed_voice_state = entry.get("voices", [])
+                    self.selected_lang = entry.get("language")
+                else:
+                    self.mixed_voice_state = entry
+                    self.selected_lang = entry[0][0] if entry and entry[0] else None
         if self.save_option == "Choose output folder" and self.selected_output_folder:
             self.save_path_label.setText(self.selected_output_folder)
             self.save_path_label.show()
         self.subtitle_combo.setCurrentText(self.subtitle_mode)
-        # Enable/disable subtitle options based on selected language
+        # Enable/disable subtitle options based on selected language (profile or voice)
-        self.subtitle_combo.setEnabled(
+        enable = self.selected_lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
-            self.selected_lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
+        self.subtitle_combo.setEnabled(enable)
-        )
         # loading gif for preview button
         loading_gif_path = get_resource_path("abogen.assets", "loading.gif")
         if loading_gif_path:
@@ -555,19 +626,26 @@ class abogen(QWidget):
         voice_layout.addWidget(QLabel("Select Voice:", self))
         voice_row = QHBoxLayout()
         self.voice_combo = QComboBox(self)
-        for v in VOICES_INTERNAL:
+        self.voice_combo.currentIndexChanged.connect(self.on_voice_combo_changed)
-            flag = FLAGS.get(v[0], "")
-            self.voice_combo.addItem(f"{flag} {v}", v)
         self.voice_combo.setStyleSheet(
             "QComboBox { min-height: 20px; padding: 6px 12px; }"
         )
-        self.voice_combo.currentIndexChanged.connect(self.on_voice_changed)
         self.voice_combo.setToolTip(
             "The first character represents the language:\n"
             '"a" => American English\n"b" => British English\n"e" => Spanish\n"f" => French\n"h" => Hindi\n"i" => Italian\n"j" => Japanese\n"p" => Brazilian Portuguese\n"z" => Mandarin Chinese\nThe second character represents the gender:\n"m" => Male\n"f" => Female'
         )
         voice_row.addWidget(self.voice_combo)
 
+        # Voice formula button
+        self.btn_voice_formula_mixer = QPushButton(self)
+        mixer_icon_path = get_resource_path("abogen.assets", "voice_mixer.png")
+        self.btn_voice_formula_mixer.setIcon(QIcon(mixer_icon_path))
+        self.btn_voice_formula_mixer.setToolTip("Mix and match voices")
+        self.btn_voice_formula_mixer.setFixedSize(40, 36)
+        self.btn_voice_formula_mixer.setStyleSheet("QPushButton { padding: 6px 12px; }")
+        self.btn_voice_formula_mixer.clicked.connect(self.show_voice_formula_dialog)
+        voice_row.addWidget(self.btn_voice_formula_mixer)
+
         # Play/Stop icons
         def make_icon(color, shape):
             pix = QPixmap(20, 20)
@@ -626,10 +704,9 @@ class abogen(QWidget):
         )
         self.subtitle_combo.setCurrentText(self.subtitle_mode)
         self.subtitle_combo.currentTextChanged.connect(self.on_subtitle_mode_changed)
-        # Enable/disable subtitle options based on selected language
+        # Enable/disable subtitle options based on selected language (profile or voice)
-        self.subtitle_combo.setEnabled(
+        enable = self.selected_lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
-            self.selected_lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
+        self.subtitle_combo.setEnabled(enable)
-        )
         subtitle_layout.addWidget(self.subtitle_combo)
         controls_layout.addLayout(subtitle_layout)
         # Output format
@@ -639,10 +716,23 @@ class abogen(QWidget):
         self.format_combo.setStyleSheet(
             "QComboBox { min-height: 20px; padding: 6px 12px; }"
         )
-        format_options = ["wav", "flac", "mp3"]
+        # Add items with display labels and underlying keys
-        self.format_combo.addItems(format_options)
+        for key, label in [
-        self.format_combo.setCurrentText(self.selected_format)
+            ("wav", "wav"),
-        self.format_combo.currentTextChanged.connect(self.on_format_changed)
+            ("flac", "flac"),
+            ("mp3", "mp3"),
+            ("opus", "opus (best compression)"),
+            ("m4b", "m4b (with chapters)"),
+        ]:
+            self.format_combo.addItem(label, key)
+        # Initialize selection by matching saved key
+        idx = self.format_combo.findData(self.selected_format)
+        if idx >= 0:
+            self.format_combo.setCurrentIndex(idx)
+        # Map selection back to key on change
+        self.format_combo.currentIndexChanged.connect(
+            lambda i: self.on_format_changed(self.format_combo.itemData(i))
+        )
         format_layout.addWidget(self.format_combo)
         controls_layout.addLayout(format_layout)
         # Save location
@@ -751,6 +841,7 @@ class abogen(QWidget):
         container_layout.addWidget(self.finish_widget)
         outer_layout.addWidget(container)
         self.setLayout(outer_layout)
+        self.populate_profiles_in_voice_combo()
 
     def open_file_dialog(self):
         if self.is_converting:
@@ -796,9 +887,7 @@ class abogen(QWidget):
         )
         dialog.setWindowModality(Qt.NonModal)
         dialog.setModal(False)
-        dialog.show()
+        dialog.show()            # We'll handle the dialog result asynchronously
-
-        # We'll handle the dialog result asynchronously
         def on_dialog_finished(result):
             if result != QDialog.Accepted:
                 return False
@@ -813,6 +902,7 @@ class abogen(QWidget):
             self.selected_chapters = all_checked_hrefs
             self.save_chapters_separately = dialog.get_save_chapters_separately()
             self.merge_chapters_at_end = dialog.get_merge_chapters_at_end()
+            self.save_as_project = dialog.get_save_as_project()
 
             # Store if the PDF has bookmarks for button text display
             if book_path.lower().endswith(".pdf"):
@@ -821,8 +911,50 @@ class abogen(QWidget):
             # Use "abogen" prefix for temporary files
             # Extract base name without extension
             base_name = os.path.splitext(os.path.basename(book_path))[0]
-            temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
+            
-            os.makedirs(temp_dir, exist_ok=True)
+            if self.save_as_project:
+                # Get project directory from user
+                project_dir = QFileDialog.getExistingDirectory(
+                    self, "Select Project Folder", "", QFileDialog.ShowDirsOnly
+                )
+                if not project_dir:
+                    # User cancelled, fallback to temp
+                    self.save_as_project = False
+                    temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
+                else:
+                    # Create project folder structure
+                    project_name = f"{base_name}_project"
+                    project_dir = os.path.join(project_dir, project_name)
+                    temp_dir = os.path.join(project_dir, "text")
+                    os.makedirs(temp_dir, exist_ok=True)
+                    
+                    # Save metadata if available
+                    meta_dir = os.path.join(project_dir, "metadata")
+                    os.makedirs(meta_dir, exist_ok=True) # Save book metadata if available
+                    if hasattr(dialog, "book_metadata"):
+                        meta_path = os.path.join(meta_dir, "book_info.txt")
+                        with open(meta_path, "w", encoding="utf-8") as f:
+                            # Clean HTML tags from metadata
+                            title = re.sub(r'<[^>]+>', '', str(dialog.book_metadata.get('title', 'Unknown')))
+                            publisher = re.sub(r'<[^>]+>', '', str(dialog.book_metadata.get('publisher', 'Unknown')))
+                            authors = [re.sub(r'<[^>]+>', '', str(author)) for author in dialog.book_metadata.get('authors', ['Unknown'])]
+                            
+                            f.write(f"Title: {title}\n")
+                            f.write(f"Authors: {', '.join(authors)}\n")
+                            f.write(f"Publisher: {publisher}\n")
+                            if dialog.book_metadata.get('description'):
+                                description = re.sub(r'<[^>]+>', '', str(dialog.book_metadata.get('description')))
+                                f.write(f"\nDescription:\n{description}\n")
+                        
+                        # Save cover image if available
+                    if dialog.book_metadata.get("cover_image"):
+                        cover_path = os.path.join(meta_dir, "cover.png")
+                        with open(cover_path, "wb") as f:
+                            f.write(dialog.book_metadata["cover_image"])
+            else:
+                temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
+                os.makedirs(temp_dir, exist_ok=True)
+                
             fd, tmp = tempfile.mkstemp(
                 prefix=f"abogen_{base_name}_", suffix=".txt", dir=temp_dir
             )
@@ -933,6 +1065,87 @@ class abogen(QWidget):
         else:
             self.subtitle_combo.setEnabled(False)
 
+    def on_voice_combo_changed(self, index):
+        data = self.voice_combo.itemData(index)
+        if isinstance(data, str) and data.startswith("profile:"):
+            pname = data.split(":", 1)[1]
+            self.selected_profile_name = pname
+            from voice_profiles import load_profiles
+
+            entry = load_profiles().get(pname, {})
+            # set mixed voices and language
+            if isinstance(entry, dict):
+                self.mixed_voice_state = entry.get("voices", [])
+                self.selected_lang = entry.get("language")
+            else:
+                self.mixed_voice_state = entry
+                self.selected_lang = entry[0][0] if entry and entry[0] else None
+            self.selected_voice = None
+            self.config["selected_profile_name"] = pname
+            self.config.pop("selected_voice", None)
+            save_config(self.config)
+            # enable subtitles based on profile language
+            self.subtitle_combo.setEnabled(
+                self.selected_lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
+            )
+        else:
+            self.mixed_voice_state = None
+            self.selected_profile_name = None
+            self.selected_voice, self.selected_lang = data, data[0]
+            self.config["selected_voice"] = data
+            if "selected_profile_name" in self.config:
+                del self.config["selected_profile_name"]
+            save_config(self.config)
+            if self.selected_lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION:
+                self.subtitle_combo.setEnabled(True)
+                self.subtitle_mode = self.subtitle_combo.currentText()
+            else:
+                self.subtitle_combo.setEnabled(False)
+
+    def update_subtitle_combo_for_profile(self, profile_name):
+        from voice_profiles import load_profiles
+
+        entry = load_profiles().get(profile_name, {})
+        lang = entry.get("language") if isinstance(entry, dict) else None
+        enable = lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
+        self.subtitle_combo.setEnabled(enable)
+
+    def populate_profiles_in_voice_combo(self):
+        # preserve current voice or profile
+        current = self.voice_combo.currentData()
+        self.voice_combo.blockSignals(True)
+        self.voice_combo.clear()
+        # re-add profiles
+        profile_icon = QIcon(get_resource_path("abogen.assets", "profile.png"))
+        for pname in load_profiles().keys():
+            self.voice_combo.addItem(profile_icon, pname, f"profile:{pname}")
+        # re-add voices
+        for v in VOICES_INTERNAL:
+            icon = QIcon()
+            flag_path = get_resource_path("abogen.assets.flags", f"{v[0]}.png")
+            if flag_path and os.path.exists(flag_path):
+                icon = QIcon(flag_path)
+            self.voice_combo.addItem(icon, f"{v}", v)
+        # restore selection
+        idx = -1
+        if self.selected_profile_name:
+            idx = self.voice_combo.findData(f"profile:{self.selected_profile_name}")
+        elif current:
+            idx = self.voice_combo.findData(current)
+        if idx >= 0:
+            self.voice_combo.setCurrentIndex(idx)
+            # Also update subtitle combo for selected profile
+            data = self.voice_combo.itemData(idx)
+            if isinstance(data, str) and data.startswith("profile:"):
+                pname = data.split(":", 1)[1]
+                self.update_subtitle_combo_for_profile(pname)
+        self.voice_combo.blockSignals(False)
+        # If no profiles exist, clear selected_profile_name from config
+        if not load_profiles():
+            if "selected_profile_name" in self.config:
+                del self.config["selected_profile_name"]
+                save_config(self.config)
+
     def convert_input_box_to_log(self):
         self.input_box.hide()
         self.log_text.show()
@@ -981,12 +1194,20 @@ class abogen(QWidget):
         QApplication.processEvents()
 
     def update_progress(self, value, etr_str):  # Add etr_str parameter
+        # Ensure progress doesn't exceed 99%
+        if value >= 100:
+            value = 99
         self.progress_bar.setValue(value)
         self.progress_bar.setFormat("%p%")  # Keep format as percentage only
         self.etr_label.setText(
             f"Estimated time remaining: {etr_str}"
         )  # Update ETR label
         self.etr_label.show()  # Show only when estimate is ready
+
+        # Disable cancel button if progress is >= 98%
+        if value >= 98:
+            self.btn_cancel.setEnabled(False)
+
         self.progress_bar.repaint()
         QApplication.processEvents()
 
@@ -1038,11 +1259,32 @@ class abogen(QWidget):
                 else self.subtitle_mode
             )
 
+            # if voice formula is not None, use the selected voice
+            if self.mixed_voice_state:
+                formula_components = [
+                    f"{name}*{weight}" for name, weight in self.mixed_voice_state
+                ]
+                voice_formula = " + ".join(filter(None, formula_components))
+            else:
+                voice_formula = self.selected_voice
+            # determine selected language: use profile setting if profile selected, else voice code
+            if self.selected_profile_name:
+                from voice_profiles import load_profiles
+
+                entry = load_profiles().get(self.selected_profile_name, {})
+                selected_lang = entry.get("language")
+            else:
+                selected_lang = self.selected_voice[0] if self.selected_voice else None
+            # fallback: extract from formula if missing
+            if not selected_lang:
+                m = re.search(r"\b([a-z])", voice_formula)
+                selected_lang = m.group(1) if m else None
+
             self.conversion_thread = ConversionThread(
                 self.selected_file,
-                self.selected_lang,
+                selected_lang,
                 speed,
-                self.selected_voice,
+                voice_formula,
                 self.save_option,
                 self.selected_output_folder,
                 subtitle_mode=actual_subtitle_mode,
@@ -1059,6 +1301,10 @@ class abogen(QWidget):
             self.conversion_thread.file_size_str = file_size_str
             # Pass max_subtitle_words from config
             self.conversion_thread.max_subtitle_words = self.max_subtitle_words
+            # Pass replace_single_newlines setting
+            self.conversion_thread.replace_single_newlines = (
+                self.replace_single_newlines
+            )
             # Pass chapter count for EPUB or PDF files
             if self.selected_file_type in ["epub", "pdf"] and hasattr(
                 self, "selected_chapters"
@@ -1289,9 +1535,24 @@ class abogen(QWidget):
         self.btn_preview.setEnabled(False)
         self.btn_preview.setToolTip("Loading...")
         self.voice_combo.setEnabled(False)
+        self.btn_voice_formula_mixer.setEnabled(False)  # Disable mixer button
         self.btn_start.setEnabled(False)  # Disable start button during preview
-        # start loading animation
+
-        self.loading_movie.start()
+        # Start loading animation - ensure signal connection is always active
+        if hasattr(self, "loading_movie"):
+            # Disconnect previous connections to avoid multiple connections
+            try:
+                self.loading_movie.frameChanged.disconnect()
+            except TypeError:
+                pass  # Ignore error if not connected
+
+            # Reconnect the signal
+            self.loading_movie.frameChanged.connect(
+                lambda: self.btn_preview.setIcon(
+                    QIcon(self.loading_movie.currentPixmap())
+                )
+            )
+            self.loading_movie.start()
 
         def pipeline_loaded_callback(np_module, kpipeline_class, error):
             self._on_pipeline_loaded_for_preview(np_module, kpipeline_class, error)
@@ -1303,23 +1564,46 @@ class abogen(QWidget):
         # stop loading animation and restore icon on error
         if error:
             self.loading_movie.stop()
-            self.btn_preview.setIcon(self.play_icon)
             self._show_error_message_box(
                 "Loading Error", f"Error loading numpy or KPipeline: {error}"
             )
+            self.btn_preview.setIcon(self.play_icon)
             self.btn_preview.setEnabled(True)
             self.btn_preview.setToolTip("Preview selected voice")
             self.voice_combo.setEnabled(True)
+            self.btn_voice_formula_mixer.setEnabled(True)  # Re-enable mixer button
             self.btn_start.setEnabled(True)  # Re-enable start button on error
             return
 
-        lang, voice, speed = (
+        # Support preview for voice profiles
-            self.selected_voice[0],
+        speed = self.speed_slider.value() / 100.0
-            self.selected_voice,
+        if self.mixed_voice_state:
-            self.speed_slider.value() / 100.0,
+            # Build voice formula string
-        )
+            components = [f"{name}*{weight}" for name, weight in self.mixed_voice_state]
+            voice = " + ".join(filter(None, components))
+            # determine language: use profile setting, else explicit mixer selection, else fallback to first voice code
+            if self.selected_profile_name:
+                from voice_profiles import load_profiles
+
+                entry = load_profiles().get(self.selected_profile_name, {})
+                lang = entry.get("language")
+            else:
+                lang = self.selected_lang
+            if not lang and self.mixed_voice_state:
+                lang = (
+                    self.mixed_voice_state[0][0][0]
+                    if self.mixed_voice_state and self.mixed_voice_state[0][0]
+                    else None
+                )
+        else:
+            lang = self.selected_voice[0]
+            voice = self.selected_voice
+
+        # use same gpu/cpu logic as in conversion
+        gpu_msg, gpu_ok = get_gpu_acceleration(self.use_gpu)
+
         self.preview_thread = VoicePreviewThread(
-            np_module, kpipeline_class, lang, voice, speed
+            np_module, kpipeline_class, lang, voice, speed, gpu_ok
         )
         self.preview_thread.finished.connect(self._play_preview_audio)
         self.preview_thread.error.connect(self._preview_error)
@@ -1329,13 +1613,15 @@ class abogen(QWidget):
         temp_wav = self.preview_thread.temp_wav
         if not temp_wav:
             self.loading_movie.stop()
-            self.btn_preview.setIcon(self.play_icon)
+
             self._show_error_message_box(
                 "Preview Error", "Preview error: No audio generated."
             )
-            self.btn_preview.setEnabled(True)
+            self.btn_preview.setIcon(self.play_icon)
             self.btn_preview.setToolTip("Preview selected voice")
+            self.btn_preview.setEnabled(True)
             self.voice_combo.setEnabled(True)
+            self.btn_voice_formula_mixer.setEnabled(True)  # Re-enable mixer button
             self.btn_start.setEnabled(True)
             return
         # stop loading animation, switch to stop icon
@@ -1381,10 +1667,16 @@ class abogen(QWidget):
 
     def _preview_cleanup(self):
         self.preview_playing = False
+        self.loading_movie.stop()
+        try:
+            self.loading_movie.frameChanged.disconnect()
+        except Exception:
+            pass  # Ignore error if not connected
         self.btn_preview.setIcon(self.play_icon)
         self.btn_preview.setToolTip("Preview selected voice")
         self.btn_preview.setEnabled(True)
         self.voice_combo.setEnabled(True)
+        self.btn_voice_formula_mixer.setEnabled(True)  # Re-enable mixer button
         self.btn_start.setEnabled(True)
 
     def _preview_error(self, msg):
@@ -1499,6 +1791,13 @@ class abogen(QWidget):
         """Show a dropdown menu for settings options."""
         menu = QMenu(self)
 
+        # Add replace single newlines option
+        newline_action = QAction("Replace single newlines with spaces", self)
+        newline_action.setCheckable(True)
+        newline_action.setChecked(self.replace_single_newlines)
+        newline_action.triggered.connect(self.toggle_replace_single_newlines)
+        menu.addAction(newline_action)
+
         # Add max words per subtitle option
         max_words_action = QAction("Configure max words per subtitle", self)
         max_words_action.triggered.connect(self.set_max_subtitle_words)
@@ -1507,14 +1806,16 @@ class abogen(QWidget):
         # Add seperator
         menu.addSeparator()
 
-        # Add shortcut to desktop (Windows only)
+        # Add shortcut to desktop (Windows or Linux)
-        if platform.system() == "Windows":
+        if platform.system() == "Windows" or platform.system() == "Linux":
-            add_shortcut_action = QAction("Create desktop shortcut", self)
+            # Use extended label on Linux
+            label = "Create desktop shortcut and install" if platform.system() == "Linux" else "Create desktop shortcut"
+            add_shortcut_action = QAction(label, self)
             add_shortcut_action.triggered.connect(self.add_shortcut_to_desktop)
             menu.addAction(add_shortcut_action)
 
         # Add reveal config option
-        reveal_config_action = QAction("Open config.json directory", self)
+        reveal_config_action = QAction("Open configuration directory", self)
         reveal_config_action.triggered.connect(self.reveal_config_in_explorer)
         menu.addAction(reveal_config_action)
 
@@ -1545,6 +1846,11 @@ class abogen(QWidget):
 
         menu.exec_(self.settings_btn.mapToGlobal(QPoint(0, self.settings_btn.height())))
 
+    def toggle_replace_single_newlines(self, checked):
+        self.replace_single_newlines = checked
+        self.config["replace_single_newlines"] = checked
+        save_config(self.config)
+
     def reveal_config_in_explorer(self):
         """Open the configuration file location in file explorer."""
         from utils import get_user_config_path
@@ -1577,62 +1883,133 @@ class abogen(QWidget):
 
     def add_shortcut_to_desktop(self):
         """Create a desktop shortcut to this program using PowerShell."""
-        import sys, subprocess
+        import sys
-        from PyQt5.QtWidgets import QMessageBox
+        from platformdirs import user_desktop_dir
+        from utils import create_process
 
         try:
-            # where to put the .lnk
+            if platform.system() == "Windows":
-            desktop = os.path.join(os.environ.get("USERPROFILE", ""), "Desktop")
+                # where to put the .lnk
-            shortcut_path = os.path.join(desktop, "abogen.lnk")
+                desktop = user_desktop_dir()
+                shortcut_path = os.path.join(desktop, "abogen.lnk")
 
-            # target exe
+                # target exe
-            python_dir = os.path.dirname(sys.executable)
+                python_dir = os.path.dirname(sys.executable)
-            target = os.path.join(python_dir, "Scripts", "abogen.exe")
+                target = os.path.join(python_dir, "Scripts", "abogen.exe")
-            if not os.path.exists(target):
+                if not os.path.exists(target):
-                QMessageBox.critical(
+                    QMessageBox.critical(
-                    self, "Shortcut Error", f"Could not find abogen.exe at:\n{target}"
+                        self, "Shortcut Error", f"Could not find abogen.exe at:\n{target}"
+                    )
+                    return
+
+                # icon (fallback to exe if missing)
+                icon = get_resource_path("abogen.assets", "icon.ico")
+                if not icon or not os.path.exists(icon):
+                    icon = target            # Create a more direct PowerShell command
+                shortcut_ps = shortcut_path.replace("'", "''").replace("\\", "\\\\")
+                target_ps = target.replace("'", "''").replace("\\", "\\\\")
+                workdir_ps = os.path.dirname(target).replace("'", "''").replace("\\", "\\\\")
+                icon_ps = icon.replace("'", "''").replace("\\", "\\\\")
+                  # Create PowerShell script as a single line with no line breaks (more reliable)
+                ps_cmd = f"$s=New-Object -ComObject WScript.Shell; $lnk=$s.CreateShortcut('{shortcut_ps}'); $lnk.TargetPath='{target_ps}'; $lnk.WorkingDirectory='{workdir_ps}'; $lnk.IconLocation='{icon_ps}'; $lnk.Save()"
+            
+                # Run PowerShell with the command directly
+                proc = create_process("powershell -NoProfile -ExecutionPolicy Bypass -Command \"" + ps_cmd + "\"")
+                proc.wait()
+            
+                if proc.returncode == 0:
+                    QMessageBox.information(
+                        self,
+                        "Shortcut Created",
+                        f"Shortcut created on desktop:\n{shortcut_path}",
+                    )
+                else:
+                    QMessageBox.critical(
+                        self,
+                        "Shortcut Error",
+                        f"PowerShell failed with exit code: {proc.returncode}"
+                    )
+            elif platform.system() == "Linux":
+                desktop = user_desktop_dir()
+                if not desktop or not os.path.isdir(desktop):
+                    QMessageBox.critical(self, "Shortcut Error", "Could not determine desktop directory.")
+                    return
+
+                shortcut_path = os.path.join(desktop, "abogen.desktop")
+
+                import shutil
+                found = shutil.which("abogen")
+                if found:
+                    target = found
+                else:
+                    local_bin = os.path.expanduser("~/.local/bin/abogen")
+                    if os.path.exists(local_bin):
+                        target = local_bin
+                    else:
+                        python_dir = os.path.dirname(sys.executable)
+                        target = os.path.join(python_dir, "bin", "abogen")
+                        if not os.path.exists(target):
+                            target_fallback = os.path.join(python_dir, "abogen")
+                            if os.path.exists(target_fallback):
+                                target = target_fallback
+                            else:
+                                QMessageBox.critical(self, "Shortcut Error", "Could not find abogen executable in PATH or common installation directories.")
+                                return
+
+                icon_path = get_resource_path("abogen.assets", "icon.png")
+
+                desktop_entry_content = f"""[Desktop Entry]
+Version={VERSION}
+Name={PROGRAM_NAME}
+Comment={PROGRAM_DESCRIPTION}
+Exec={target}
+Icon={icon_path}
+Terminal=false
+Type=Application
+Categories=AudioVideo;Audio;Utility;
+"""
+                with open(shortcut_path, "w", encoding="utf-8") as f:
+                    f.write(desktop_entry_content)
+
+                os.chmod(shortcut_path, 0o755)
+
+                QMessageBox.information(
+                    self,
+                    "Shortcut Created",
+                    f"Shortcut created on desktop:\n{shortcut_path}",
                 )
-                return
 
-            # icon (fallback to exe if missing)
+                # Offer installation for current user under ~/.local/share/applications
-            icon = get_resource_path("abogen.assets", "icon.ico")
+                reply = QMessageBox.question(
-            if not icon or not os.path.exists(icon):
+                    self,
-                icon = target
+                    "Install Application Entry",
+                    "Install application entry for current user?",
+                    QMessageBox.Yes | QMessageBox.No,
+                )
+                if reply == QMessageBox.Yes:
+                    import shutil
+                    user_app_dir = os.path.expanduser("~/.local/share/applications")
+                    os.makedirs(user_app_dir, exist_ok=True)
+                    user_entry = os.path.join(user_app_dir, "abogen.desktop")
+                    try:
+                        shutil.copyfile(shortcut_path, user_entry)
+                        os.chmod(user_entry, 0o644)
+                        QMessageBox.information(
+                            self,
+                            "Installation Complete",
+                            f"Desktop entry installed to {user_entry}",
+                        )
+                    except Exception as e:
+                        QMessageBox.warning(
+                            self,
+                            "Install Error",
+                            f"Could not install entry:\n{e}",
+                        )
+            else:
+                QMessageBox.information(
+                    self, "Unsupported OS", "Desktop shortcut creation is not supported on this operating system."
+                )
 
-            # PowerShell command to make the shortcut
-            ps_cmd = r"""
-                    $s = New-Object -ComObject WScript.Shell
-                    $lnk = $s.CreateShortcut('{lnk}')
-                    $lnk.TargetPath = '{tgt}'
-                    $lnk.WorkingDirectory = '{cwd}'
-                    $lnk.IconLocation = '{ico}'
-                    $lnk.Save()
-                    """.format(
-                lnk=shortcut_path.replace("'", "''"),
-                tgt=target.replace("'", "''"),
-                cwd=os.path.dirname(target).replace("'", "''"),
-                ico=icon.replace("'", "''"),
-            ).strip()
-
-            subprocess.run(
-                ["powershell", "-NoProfile", "-Command", ps_cmd],
-                check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-            )
-
-            QMessageBox.information(
-                self,
-                "Shortcut Created",
-                f"Shortcut created on desktop:\n{shortcut_path}",
-            )
-
-        except subprocess.CalledProcessError as e:
-            QMessageBox.critical(
-                self,
-                "Shortcut Error",
-                f"PowerShell failed:\n{e.stderr.decode(errors='ignore')}",
-            )
         except Exception as e:
             QMessageBox.critical(
                 self, "Shortcut Error", f"Could not create shortcut:\n{e}"
@@ -1642,6 +2019,50 @@ class abogen(QWidget):
         self.config["check_updates"] = checked
         save_config(self.config)
 
+    def show_voice_formula_dialog(self):
+        from voice_profiles import load_profiles
+
+        profiles = load_profiles()
+        initial_state = None
+        selected_profile = self.selected_profile_name
+        if selected_profile:
+            entry = profiles.get(selected_profile, {})
+            if isinstance(entry, dict):
+                initial_state = entry.get("voices", [])
+            else:
+                initial_state = entry
+        elif self.mixed_voice_state is not None:
+            initial_state = self.mixed_voice_state
+        elif self.selected_voice:
+            # If a single voice is selected, default to first profile if available
+            if profiles:
+                first_profile = next(iter(profiles))
+                entry = profiles[first_profile]
+                selected_profile = first_profile
+                if isinstance(entry, dict):
+                    initial_state = entry.get("voices", [])
+                else:
+                    initial_state = entry
+            else:
+                initial_state = []
+        else:
+            initial_state = []
+        dialog = VoiceFormulaDialog(
+            self, initial_state=initial_state, selected_profile=selected_profile
+        )
+        if dialog.exec_() == QDialog.Accepted:
+            if dialog.current_profile:
+                self.selected_profile_name = dialog.current_profile
+                self.config["selected_profile_name"] = dialog.current_profile
+                if "selected_voice" in self.config:
+                    del self.config["selected_voice"]
+                save_config(self.config)
+                self.populate_profiles_in_voice_combo()
+                idx = self.voice_combo.findData(f"profile:{dialog.current_profile}")
+                if idx >= 0:
+                    self.voice_combo.setCurrentIndex(idx)
+            self.mixed_voice_state = dialog.get_selected_voices()
+
     def show_about_dialog(self):
         """Show an About dialog with program information including GitHub link."""
         # Get application icon for dialog
@@ -1871,3 +2292,4 @@ class abogen(QWidget):
                 "Setting Saved",
                 f"Maximum words per subtitle set to {value}.",
             )
+

abogen/utils.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import json
 import warnings
 import platform
@@ -32,6 +33,14 @@ def get_resource_path(package, resource):
     except (ImportError, FileNotFoundError):
         pass
 
+    # Always try to resolve as a relative path from this file
+    parts = package.split(".")
+    rel_path = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), *parts[1:], resource
+    )
+    if os.path.exists(rel_path):
+        return rel_path
+
     # Fallback to local file system
     try:
         # Extract the subdirectory from package name (e.g., 'assets' from 'abogen.assets')
@@ -50,7 +59,7 @@ def get_resource_path(package, resource):
 def get_version():
     """Return the current version of the application."""
     try:
-        with open(get_resource_path("abogen", "VERSION"), "r") as f:
+        with open(get_resource_path("/", "VERSION"), "r") as f:
             return f.read().strip()
     except Exception:
         return "Unknown"
@@ -58,10 +67,20 @@ def get_version():
 
 # Define config path
 def get_user_config_path():
-    if os.name == "nt":
+    from platformdirs import user_config_dir
-        config_dir = os.path.join(os.environ["APPDATA"], "abogen")
+
+    # TODO Config directory is changed for Linux and MacOS. But if old config exists, it will be used.
+    # On non‑Windows, prefer ~/.config/abogen if it already exists
+    if platform.system() != "Windows":
+        custom_dir = os.path.join(os.path.expanduser("~"), ".config", "abogen")
+        if os.path.exists(custom_dir):
+            config_dir = custom_dir
+        else:
+            config_dir = user_config_dir("abogen", appauthor=False, roaming=True)
     else:
-        config_dir = os.path.join(os.path.expanduser("~"), ".config", "abogen")
+        # Windows and fallback case
+        config_dir = user_config_dir("abogen", appauthor=False, roaming=True)
+
     os.makedirs(config_dir, exist_ok=True)
     return os.path.join(config_dir, "config.json")
 
@@ -69,18 +88,104 @@ def get_user_config_path():
 _sleep_procs = {"Darwin": None, "Linux": None}  # Store sleep prevention processes
 
 
-def clean_text(text):
+def clean_text(text, *args, **kwargs):
-    # Trim spaces and tabs at the start and end of each line, preserving blank lines
+    # Load replace_single_newlines from config
-    text = "\n".join(line.strip() for line in text.splitlines())
+    cfg = load_config()
+    replace_single_newlines = cfg.get("replace_single_newlines", False)
+    # Collapse all whitespace (excluding newlines) into single spaces per line and trim edges
+    lines = [re.sub(r"[^\S\n]+", " ", line).strip() for line in text.splitlines()]
+    text = "\n".join(lines)
     # Standardize paragraph breaks (multiple newlines become exactly two) and trim overall whitespace
     text = re.sub(r"\n{3,}", "\n\n", text).strip()
-    # Replace single newlines with spaces, but preserve double newlines
+    # Optionally replace single newlines with spaces, but preserve double newlines
-    # text = re.sub(r"(?<!\n)\n(?!\n)", " ", text)
+    if replace_single_newlines:
-    # Collapse multiple spaces and tabs into a single space
+        text = re.sub(r"(?<!\n)\n(?!\n)", " ", text)
-    text = re.sub(r"[ \t]+", " ", text)
     return text
 
 
+default_encoding = sys.getfilesystemencoding()
+
+def create_process(cmd, stdin=None, text=True):
+    import logging
+    logger = logging.getLogger(__name__)
+    
+    # Configure root logger to output to console if not already configured
+    root = logging.getLogger()
+    if not root.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        formatter = logging.Formatter('%(message)s')
+        handler.setFormatter(formatter)
+        root.addHandler(handler)
+        root.setLevel(logging.INFO)
+    
+    # Determine shell usage: use shell only for string commands
+    use_shell = isinstance(cmd, str)
+    kwargs = {
+        "shell": use_shell,
+        "stdout": subprocess.PIPE,
+        "stderr": subprocess.STDOUT,
+        "bufsize": 1,  # Line buffered
+    }
+
+    if text:
+        # Configure for text I/O
+        kwargs["text"] = True
+        kwargs["encoding"] = default_encoding
+        kwargs["errors"] = "replace"
+    else:
+        # Configure for binary I/O
+        kwargs["text"] = False
+        # For binary mode, 'encoding' and 'errors' arguments must not be passed to Popen
+        kwargs["bufsize"] = 0  # Use unbuffered mode for binary data
+
+    if stdin is not None:
+        kwargs["stdin"] = stdin
+
+    if platform.system() == "Windows":
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        startupinfo.wShowWindow = subprocess.SW_HIDE
+        kwargs.update(
+            {"startupinfo": startupinfo, "creationflags": subprocess.CREATE_NO_WINDOW}
+        )
+
+    # Print the command being executed
+    print(f"Executing: {cmd if isinstance(cmd, str) else ' '.join(cmd)}")
+    
+    proc = subprocess.Popen(cmd, **kwargs)
+    
+    # Stream output to console in real-time
+    if proc.stdout:
+        def _stream_output(stream):
+            if text:
+                # For text mode, read character by character for real-time output
+                while True:
+                    char = stream.read(1)
+                    if not char:
+                        break
+                    # Direct write to stdout for immediate feedback
+                    sys.stdout.write(char)
+                    sys.stdout.flush()
+            else:
+                # For binary mode, read small chunks
+                while True:
+                    chunk = stream.read(1)  # Read byte by byte for real-time output
+                    if not chunk:
+                        break
+                    try:
+                        # Try to decode binary data for display
+                        sys.stdout.write(chunk.decode(default_encoding, errors='replace'))
+                        sys.stdout.flush()
+                    except Exception:
+                        pass
+            stream.close()
+        
+        # Start a daemon thread to handle output streaming
+        Thread(target=_stream_output, args=(proc.stdout,), daemon=True).start()
+
+    return proc
+
+
 def load_config():
     try:
         with open(get_user_config_path(), "r", encoding="utf-8") as f:
@@ -98,8 +203,10 @@ def save_config(config):
 
 
 def calculate_text_length(text):
-    # Remove double newlines (replace them with single newlines)
+    # Ignore chapter markers
-    cleaned_text = text.replace("\n\n", "")
+    text_no_markers = re.sub(r"<<CHAPTER_MARKER:.*?>>", "", text)
+    # Ignore newlines
+    cleaned_text = text_no_markers.replace("\n", "")
     # Calculate character count
     char_count = len(cleaned_text)
     return char_count
@@ -125,21 +232,15 @@ def prevent_sleep_start():
             0x80000000 | 0x00000001 | 0x00000040
         )  # ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED
     elif system == "Darwin":
-        _sleep_procs["Darwin"] = subprocess.Popen(["caffeinate"])
+        _sleep_procs["Darwin"] = create_process("caffeinate")
     elif system == "Linux":
         try:
-            _sleep_procs["Linux"] = subprocess.Popen(
+            _sleep_procs["Linux"] = create_process(
-                [
+                "systemd-inhibit --what=sleep --why=TextToAudiobook conversion sleep 999999"
-                    "systemd-inhibit",
-                    "--what=sleep",
-                    "--why=TextToAudiobook conversion",
-                    "sleep",
-                    "999999",
-                ]
             )
         except Exception:
             try:
-                subprocess.Popen(["xdg-screensaver", "reset"])
+                create_process("xdg-screensaver reset")
             except Exception:
                 pass
 

abogen/voice_formulas.py

@@ -0,0 +1,57 @@
+import re
+from constants import VOICES_INTERNAL
+
+
+# Calls parsing and loads the voice to gpu or cpu
+def get_new_voice(pipeline, formula, use_gpu):
+    try:
+        weighted_voice = parse_voice_formula(pipeline, formula)
+        # device = "cuda" if use_gpu else "cpu"
+        # Setting the device "cuda" gives "Error occurred: split_with_sizes(): argument 'split_sizes' (position 2)"
+        # error when the device is gpu. So disabling this for now.
+        device = "cpu"
+        return weighted_voice.to(device)
+    except Exception as e:
+        raise ValueError(f"Failed to create voice: {str(e)}")
+
+
+# Parse the formula and get the combined voice tensor
+def parse_voice_formula(pipeline, formula):
+    if not formula.strip():
+        raise ValueError("Empty voice formula")
+
+    # Initialize the weighted sum
+    weighted_sum = None
+
+    total_weight = calculate_sum_from_formula(formula)
+
+    # Split the formula into terms
+    voices = formula.split("+")
+
+    for term in voices:
+        # Parse each term (format: "voice_name*0.333")
+        voice_name, weight = term.strip().split("*")
+        weight = float(weight.strip())
+        # normalize the weight
+        weight /= total_weight if total_weight > 0 else 1.0
+        voice_name = voice_name.strip()
+
+        # Get the voice tensor
+        if voice_name not in VOICES_INTERNAL:
+            raise ValueError(f"Unknown voice: {voice_name}")
+
+        voice_tensor = pipeline.load_single_voice(voice_name)
+
+        # Add to weighted sum
+        if weighted_sum is None:
+            weighted_sum = weight * voice_tensor
+        else:
+            weighted_sum += weight * voice_tensor
+
+    return weighted_sum
+
+
+def calculate_sum_from_formula(formula):
+    weights = re.findall(r"\* *([\d.]+)", formula)
+    total_sum = sum(float(weight) for weight in weights)
+    return total_sum

abogen/voice_profiles.py

@@ -0,0 +1,59 @@
+import os
+import json
+from utils import get_user_config_path
+
+
+def _get_profiles_path():
+    config_path = get_user_config_path()
+    config_dir = os.path.dirname(config_path)
+    return os.path.join(config_dir, "voice_profiles.json")
+
+
+def load_profiles():
+    """Load all voice profiles from JSON file."""
+    path = _get_profiles_path()
+    if os.path.exists(path):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                # always expect abogen_voice_profiles wrapper
+                if isinstance(data, dict) and "abogen_voice_profiles" in data:
+                    return data["abogen_voice_profiles"]
+                # fallback: treat as profiles dict
+                if isinstance(data, dict):
+                    return data
+        except Exception:
+            return {}
+    return {}
+
+
+def save_profiles(profiles):
+    """Save all voice profiles to JSON file."""
+    path = _get_profiles_path()
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        # always save with abogen_voice_profiles wrapper
+        json.dump({"abogen_voice_profiles": profiles}, f, indent=2)
+
+
+def delete_profile(name):
+    """Remove a profile by name."""
+    profiles = load_profiles()
+    if name in profiles:
+        del profiles[name]
+        save_profiles(profiles)
+
+
+def duplicate_profile(src, dest):
+    """Duplicate an existing profile."""
+    profiles = load_profiles()
+    if src in profiles and dest:
+        profiles[dest] = profiles[src]
+        save_profiles(profiles)
+
+
+def export_profiles(export_path):
+    """Export all profiles to specified JSON file."""
+    profiles = load_profiles()
+    with open(export_path, "w", encoding="utf-8") as f:
+        json.dump({"abogen_voice_profiles": profiles}, f, indent=2)

demo/README.md

@@ -40,11 +40,6 @@ Run this FFmpeg command to create the tiny video:
 ffmpeg -loop 1 -framerate 24 -i bg.jpg -i audio.wav -vf "ass=your_subtitle_demo.ass" -c:v libvpx-vp9 -b:v 0 -crf 30 -c:a libopus -shortest demo.webm
 ```
 
-That's it! The magic happens because:
-- We use a single static background image instead of many frames
-- The subtitles are stored as text (vector data), not as pixels
-- VP9 video codec with Opus audio provides excellent compression
-
 ## For Higher Quality (But Larger) Video (.mp4)
 
 If you need better quality for distribution, use this command instead:

pyproject.toml

@@ -15,11 +15,15 @@ keywords = ["audiobook", "epub", "pdf", "text-to-speech", "subtitle", "tts", "ko
 dependencies = [
     "PyQt5>=5.15.11",
     "kokoro>=0.9.4",
-    "ebooklib>=0.18",
+    "ebooklib>=0.19",
     "beautifulsoup4>=4.13.4",
     "PyMuPDF>=1.25.5",
+    "platformdirs>=4.3.7",
     "soundfile>=0.13.1",
-    "pygame>=2.6.1"
+    "pygame>=2.6.1",
+    "charset_normalizer>=3.4.1",
+    "chardet>=5.2.0",
+    "static_ffmpeg>=2.13"
 ]
 
 classifiers = [
@@ -52,10 +56,9 @@ abogen-cli = "abogen.main:main"
 exclude = [
     "/.github",
     "/demo",
-    "/demo",
+    "/abogen/resources",
     "/abogen/assets/create_shortcuts.bat",
     "WINDOWS_INSTALL.bat",
-    
 ]
 
 [tool.hatch.build.targets.wheel]