Update changelog

v1.0.9
Added new option: Subtitle format
2026-07-18 13:40:27 +02:00 · 2025-05-28 13:40:39 +03:00 · 2025-05-28 13:39:25 +03:00 · 2025-05-28 13:28:59 +03:00 · 2025-05-28 01:12:38 +03:00 · 2025-05-28 00:39:08 +03:00
24 changed files with 2071 additions and 1108 deletions
@@ -1,3 +1,58 @@
+# v1.0.9
+- Added chunking/segmenting system that fixes memory outage issues when processing large audio files.
+- Added new option: `Subtitle format`, allowing users to choose between `srt` , `ass (wide)`, `ass (narrow)`, and `ass (centered wide)` and `ass (centered narrow)`
+- Improved chapter filename generation with smart word-boundary truncation at 80 characters, preventing mid-word cuts in filenames.
+- `Composer` and `Genre` metadata fields for M4B files are now editable from the text editor.
+- Improvements in documentation and code.
+
+# v1.0.8
+- Added support for AMD GPUs in Linux (Special thanks to @hg000125 for his contribution in #23)
+- Added voice preview caching system that stores generated previews in the cache folder, mentioned by @jborza in #22
+- Added extra metadata support for chaptered M4B files, ensuring better compatibility with audiobook players.
+- Added new option: `Separate chapters audio format`, allowing to choose between `wav`, `mp4`, `flac` and `opus` formats for chaptered audio files.
+- Added a download tracker that displays informative messages while downloading Kokoro models or voices from HuggingFace.
+- Skipping PyTorch CUDA installation if GPU is not NVIDIA in WINDOWS_INSTALL.bat script, preventing unnecessary installation of PyTorch.
+- Removed `abogen_` prefix that was adding to converted books in temp directory.
+- Fixed voice preview player keeps playing silently at the background after preview ends.
+- Fixed not writing separate chapters audio when output is OPUS.
+- Improved input box background color handling, fixed display issues in Linux.
+- Updated profile and voice mixer icons, better visibility and aesthetics in voice mixer.
+- Better sleep state handling for Linux.
+- Improvements in documentation and code.
+
+# 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.
@@ -6,3 +61,18 @@
 - 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 #2
+- Improvements in code and documentation.
@@ -2,7 +2,7 @@

 [![Build Status](https://github.com/denizsafak/abogen/actions/workflows/test_pip.yml/badge.svg)](https://github.com/denizsafak/abogen/actions)
 [![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)
+[![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)
@@ -14,55 +14,92 @@ 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
-# For NVIDIA GPUs:
-pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128

-# Install abogen
-pip install abogen
-```
-Alternatively, for an easier setup on Windows:
+#### OPTION 1: Install using script
 1. [Download](https://github.com/denizsafak/abogen/archive/refs/heads/main.zip) the repository
 2. Extract the ZIP file
 3. Run `WINDOWS_INSTALL.bat` by double-clicking it

 This method handles everything automatically - installing all dependencies including CUDA in a self-contained environment without requiring a separate Python installation. (You still need to install [espeak-ng](https://github.com/espeak-ng/espeak-ng/releases/latest).)

+> [!NOTE]
+> You don't need to install Python separately. The script will install Python automatically.
+
+#### OPTION 2: Install using pip
+```bash
+# Create a virtual environment (optional)
+python -m venv venv
+venv\Scripts\activate
+
+# For NVIDIA GPUs:
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
+
+# For AMD GPUs:
+# Not supported yet, because ROCm is not available on Windows. Use Linux if you have AMD GPU.
+
+# Install abogen
+pip install abogen
+```
+
 ### Mac
 ```bash
 # Install espeak-ng
 brew install espeak-ng

+# Create a virtual environment (recommended)
+python3 -m venv venv
+source venv/bin/activate
+
 # Install abogen
-pip install abogen # (I have not tested it)
+pip3 install abogen
 ```
 ### Linux
 ```bash
 # Install espeak-ng
+sudo apt install espeak-ng # Ubuntu/Debian
+sudo pacman -S espeak-ng # Arch Linux
+sudo dnf install espeak-ng # Fedora

-# Ubuntu/Debian
-sudo apt install espeak-ng
-# Arch Linux
-sudo pacman -S espeak-ng
-# Fedora
-sudo dnf install espeak-ng
+# Create a virtual environment (recommended)
+python3 -m venv venv
+source venv/bin/activate

 # Install abogen
-pip install abogen
+pip3 install abogen
+
+# For NVIDIA GPUs:
+# Already supported, no need to install CUDA separately.
+
+# For AMD GPUs:
+# After installing abogen, we need to uninstall the existing torch package
+pip3 uninstall torch 
+pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.4
 ```
+> [!TIP]
+> 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
+>```
+
+> [!TIP]
 > 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.

-Then simply run by typing:
+> Special thanks to [@hg000125](https://github.com/hg000125) for his contribution in [#23](https://github.com/denizsafak/abogen/issues/23). AMD GPU support is possible thanks to his work.
+
+## `How to run?`
+If you installed using pip, you can simply run the following command to start Abogen:

 ```bash
 abogen
 ```
+> [!TIP]
+> 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)
@@ -85,16 +122,20 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 - **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**:
    - **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**: Automatically configures the maximum number of words per subtitle entry.
+    - **Configure max words per subtitle**: Configures the maximum number of words per subtitle entry.
+    - **Subtitle format**: Configures the subtitle format as `srt`, `ass (wide)`, `ass (narrow)`, `ass (centered wide)`, or `ass (centered narrow)`.
+    - **Separate chapters audio format**: Configures the audio format for separate chapters as `wav`, `flac`, `mp3`, or `opus`.
    - **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 temporary files**: Deletes all temporary files created during the conversion process.
+    - **Clear temporary files**: Deletes temporary files created during the conversion or preview.
    - **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`.

@@ -103,6 +144,41 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex

 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)
+
+## `About Metadata Tags`
+Similar to chapter markers, it is possible to add metadata tags to `M4B` files. This is useful for audiobook players that support metadata, allowing you to add information like title, author, year, etc. Abogen automatically adds these tags when you process ePUB or PDF files, but you can also add them manually to your text files. Add metadata tags **at the beginning of your text file** like this:
+```
+<<METADATA_TITLE:Title>>
+<<METADATA_ARTIST:Author>>
+<<METADATA_ALBUM:Album Title>>
+<<METADATA_YEAR:Year>>
+<<METADATA_ALBUM_ARTIST:Album Artist>>
+<<METADATA_COMPOSER:Narrator>>
+<<METADATA_GENRE:Audiobook>>
+```
+
 ## `Supported Languages`
 ```
 # 🇺🇸 'a' => American English, 🇬🇧 'b' => British English
@@ -119,11 +195,13 @@ For a complete list of supported languages and voices, refer to Kokoro's [VOICES
 ## `MPV Config`
 I highly recommend using [MPV](https://mpv.io/installation/) to play your audio files, as it supports displaying subtitles even without a video track. Here's my `mpv.conf`:
 ```
+# --- MPV Settings ---
 save-position-on-quit
 keep-open=yes
--audio-device=openal
--sub-margin-x=235
--sub-pos=60
+# --- Subtitle ---
+sub-ass-override=no
+sub-margin-y=50
+sub-margin-x=50
 # --- Audio Quality ---
 audio-spdif=ac3,dts,eac3,truehd,dts-hd
 audio-channels=auto
@@ -131,19 +209,56 @@ 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)**
 - [autiobooks](https://github.com/plusuncold/autiobooks): Automatically convert epubs to audiobooks
 - [pdf-narrator](https://github.com/mateogon/pdf-narrator): Convert your PDFs and EPUBs into audiobooks effortlessly.
 - [epub_to_audiobook](https://github.com/p0n1/epub_to_audiobook): EPUB to audiobook converter, optimized for Audiobookshelf
+- [ebook2audiobook](https://github.com/DrewThomasson/ebook2audiobook): Convert ebooks to audiobooks with chapters and metadata using dynamic AI models and voice cloning

 ## `Roadmap`
- [ ] Improve PDF support for better text extraction.
- [ ] Add chapter metadata for .m4a files using ffmpeg-bin.
+- [ ] Add OCR scan feature for PDF files using docling.
+- [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.
- [x] Add voice formula feature that enables mixing different voice models. #1
- [ ] Add support for kokoro-onnx.
+- [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 (If it's necessary).
 - [ ] Add dark mode.

 ## `Troubleshooting`
@@ -160,6 +275,7 @@ 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
+pip install build     # Install the build package
 python -m build       # Builds the package in dist folder (optional)
 abogen                # Opens the GUI
 ```
@@ -170,7 +286,7 @@ Feel free to explore the code and make any changes you like.
 - 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/).
+- 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), [Adjust](https://icons8.com/icon/21698/adjust) 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.
@@ -219,15 +219,33 @@ 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
+%PYTHON_CONSOLE_PATH% -m pip install --upgrade setuptools setuptools-scm wheel sphinx hatchling --no-warn-script-location
 if errorlevel 1 (
    echo Failed to install setup requirements.
    pause
    exit /b
 )

+:: Install gpustat
+echo Installing gpustat...
+%PYTHON_CONSOLE_PATH% -m pip install gpustat --no-warn-script-location
+if errorlevel 1 (
+    echo Failed to install gpustat.
+    pause
+    exit /b
+)
+
 :: Install project and dependencies from pyproject.toml
 echo Checking and installing project dependencies...
 if exist %PYPROJECT_FILE% (
@@ -254,11 +272,15 @@ if "%MISAKI_LANG%" NEQ "en" (
    )
 )

+:: Check for NVIDIA GPU via is_nvidia()
+for /f %%i in ('%PYTHON_CONSOLE_PATH% -c "from abogen.is_nvidia import check; print(check())"') do set IS_NVIDIA=%%i
+
 :: Check if torch is installed with CUDA support
 echo Checking CUDA availability...
-for /f %%i in ('%PYTHON_CONSOLE_PATH% -c "from torch.cuda import is_available; print(is_available())"') do set cuda_available=%%i
+if /I "%IS_NVIDIA%"=="true" (
+    for /f %%i in ('%PYTHON_CONSOLE_PATH% -c "from torch.cuda import is_available; print(is_available())"') do set cuda_available=%%i

-if "%cuda_available%"=="False" (
+    if "%cuda_available%"=="False" (
        echo Installing PyTorch with CUDA %CUDA_VERSION% support...
        %PYTHON_CONSOLE_PATH% -m pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu%CUDA_VERSION% --no-warn-script-location
        echo.
@@ -267,8 +289,11 @@ if "%cuda_available%"=="False" (
            pause
            exit /b
        )
+    ) else (
+        echo CUDA is available on NVIDIA GPU.
+    )
 ) else (
-    echo CUDA is available.
+    echo GPU is not NVIDIA. Skipping PyTorch CUDA installation.
 )

 :: Ask user if they want to create a desktop shortcut
@@ -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
@@ -1 +1 @@
-1.0.3
+1.0.9
@@ -37,6 +37,7 @@ class HandlerDialog(QDialog):
    # Class variables to remember checkbox states between dialog instances
    _save_chapters_separately = False
    _merge_chapters_at_end = True
+    _save_as_project = False  # New class variable for save_as_project option

    def __init__(self, book_path, file_type=None, checked_chapters=None, parent=None):
        super().__init__(parent)
@@ -64,6 +65,7 @@ class HandlerDialog(QDialog):
        # Initialize save chapters flags from class variables
        self.save_chapters_separately = HandlerDialog._save_chapters_separately
        self.merge_chapters_at_end = HandlerDialog._merge_chapters_at_end
+        self.save_as_project = HandlerDialog._save_as_project

        # Load the book based on file type
        try:
@@ -934,6 +936,7 @@ class HandlerDialog(QDialog):
    def _build_pdf_tree(self):
        outline = self.pdf_doc.get_toc()
        self.has_pdf_bookmarks = bool(outline)
+        self.bookmark_items_map = {}

        if not outline:
            self._build_pdf_pages_tree()
@@ -976,20 +979,23 @@ class HandlerDialog(QDialog):
                        else self.pdf_doc.resolve_link(page)[0]
                    )
                    page_id = f"page_{page_num+1}"
-
+                    # attach chapters on same page under original
+                    if page_num in self.bookmark_items_map:
+                        orig = self.bookmark_items_map[page_num]
+                        child = QTreeWidgetItem(orig, [f"{title} (Same page)"])
+                        child.setData(0, Qt.UserRole, page_id)
+                        child.setFlags(child.flags() & ~Qt.ItemIsUserCheckable)
+                        continue
                    bookmark_item = QTreeWidgetItem(parent_item, [title])
                    bookmark_item.setData(0, Qt.UserRole, page_id)
-                    bookmark_item.setFlags(
-                        bookmark_item.flags() | Qt.ItemIsUserCheckable
-                    )
-                    bookmark_item.setCheckState(
-                        0,
-                        (
-                            Qt.Checked
-                            if page_id in self.checked_chapters
-                            else Qt.Unchecked
-                        ),
-                    )
+                    # only allow checking if this chapter has content
+                    if self.content_lengths.get(page_id, 0) > 0:
+                        bookmark_item.setFlags(bookmark_item.flags() | Qt.ItemIsUserCheckable)
+                        bookmark_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+                    else:
+                        bookmark_item.setFlags(bookmark_item.flags() & ~Qt.ItemIsUserCheckable)
+                    # map for uncategorized pages
+                    self.bookmark_items_map[page_num] = bookmark_item

                    added_pages.add(page_num)

@@ -1012,30 +1018,39 @@ class HandlerDialog(QDialog):

                        page_item = QTreeWidgetItem(bookmark_item, [page_title])
                        page_item.setData(0, Qt.UserRole, page_id)
+                        # only allow checking if this sub-page has content
+                        if self.content_lengths.get(page_id, 0) > 0:
                            page_item.setFlags(page_item.flags() | Qt.ItemIsUserCheckable)
-                        page_item.setCheckState(
-                            0,
-                            (
-                                Qt.Checked
-                                if page_id in self.checked_chapters
-                                else Qt.Unchecked
-                            ),
-                        )
+                            page_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+                        else:
+                            page_item.setFlags(page_item.flags() & ~Qt.ItemIsUserCheckable)

                        added_pages.add(sub_page_num)

-                    if len(entry) > 3 and isinstance(entry[3], list):
-                        build_outline_tree(entry[3], bookmark_item)
-
        build_outline_tree(outline, self.treeWidget)

        covered_pages = set(added_pages)
-
-        uncategorized_pages = [
-            i for i in range(len(self.pdf_doc)) if i not in covered_pages
-        ]
-        if uncategorized_pages:
-            self._add_other_pages(uncategorized_pages)
+        # attach any pages without direct bookmarks under nearest preceding chapter
+        uncategorized_pages = [i for i in range(len(self.pdf_doc)) if i not in covered_pages]
+        for page_num in uncategorized_pages:
+            # find nearest previous bookmark
+            prev_nums = [n for n in sorted(self.bookmark_items_map) if n < page_num]
+            parent_item = self.bookmark_items_map[prev_nums[-1]] if prev_nums else self.treeWidget
+            page_id = f"page_{page_num+1}"
+            title = f"Page {page_num+1}"
+            text = self.content_texts.get(page_id, "").strip()
+            if text:
+                first = text.split("\n", 1)[0].strip()
+                if first and len(first) < 100:
+                    title += f" - {first}"
+            page_item = QTreeWidgetItem(parent_item, [title])
+            page_item.setData(0, Qt.UserRole, page_id)
+            # only allow checking if uncategorized page has content
+            if self.content_lengths.get(page_id, 0) > 0:
+                page_item.setFlags(page_item.flags() | Qt.ItemIsUserCheckable)
+                page_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+            else:
+                page_item.setFlags(page_item.flags() & ~Qt.ItemIsUserCheckable)

    def _build_pdf_pages_tree(self):
        pages_item = QTreeWidgetItem(self.treeWidget, ["Pages"])
@@ -1056,34 +1071,12 @@ class HandlerDialog(QDialog):

            page_item = QTreeWidgetItem(pages_item, [page_title])
            page_item.setData(0, Qt.UserRole, page_id)
+            # only allow checking if standalone page has content
+            if self.content_lengths.get(page_id, 0) > 0:
                page_item.setFlags(page_item.flags() | Qt.ItemIsUserCheckable)
-            page_item.setCheckState(
-                0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked
-            )
-
-    def _add_other_pages(self, uncategorized_pages):
-        other_pages = QTreeWidgetItem(self.treeWidget, ["Other Pages"])
-        other_pages.setFlags(other_pages.flags() & ~Qt.ItemIsUserCheckable)
-        font = other_pages.font(0)
-        font.setBold(True)
-        other_pages.setFont(0, font)
-
-        for page_num in uncategorized_pages:
-            page_id = f"page_{page_num+1}"
-            page_title = f"Page {page_num+1}"
-
-            page_text = self.content_texts.get(page_id, "").strip()
-            if page_text:
-                first_line = page_text.split("\n", 1)[0].strip()
-                if first_line and len(first_line) < 100:
-                    page_title += f" - {first_line}"
-
-            page_item = QTreeWidgetItem(other_pages, [page_title])
-            page_item.setData(0, Qt.UserRole, page_id)
-            page_item.setFlags(page_item.flags() | Qt.ItemIsUserCheckable)
-            page_item.setCheckState(
-                0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked
-            )
+                page_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+            else:
+                page_item.setFlags(page_item.flags() & ~Qt.ItemIsUserCheckable)

    def _are_provided_checks_relevant(self):
        if not self.checked_chapters:
@@ -1108,7 +1101,7 @@ class HandlerDialog(QDialog):
        self.previewEdit.setStyleSheet("QTextEdit { border: none; }")

        self.previewInfoLabel = QLabel(
-            '*Note: You can modify the content later using the "Edit" button in the input box or by accessing the temporary files directory through settings.',
+            '*Note: You can modify the content later using the "Edit" button in the input box or by accessing the temporary files directory through settings (if not saved in a project folder).',
            self,
        )
        self.previewInfoLabel.setWordWrap(True)
@@ -1183,7 +1176,6 @@ class HandlerDialog(QDialog):
        self.save_chapters_checkbox.setChecked(self.save_chapters_separately)
        self.save_chapters_checkbox.stateChanged.connect(self.on_save_chapters_changed)
        leftLayout.addWidget(self.save_chapters_checkbox)        
-
        self.merge_chapters_checkbox = QCheckBox(
            "Create a merged version at the end", self
        )
@@ -1193,6 +1185,19 @@ class HandlerDialog(QDialog):
        )
        leftLayout.addWidget(self.merge_chapters_checkbox)
        
+        self.save_as_project_checkbox = QCheckBox(
+            "Save in a project folder with metadata", self
+        )
+        self.save_as_project_checkbox.setToolTip(
+            "Save the converted item in a project folder with metadata files. "
+            "(Useful if you want to work with converted items in the future.)"
+        )
+        self.save_as_project_checkbox.setChecked(self.save_as_project)
+        self.save_as_project_checkbox.stateChanged.connect(
+            self.on_save_as_project_changed
+        )
+        leftLayout.addWidget(self.save_as_project_checkbox)
+
        leftLayout.addWidget(buttons)

        leftWidget = QWidget()
@@ -1489,8 +1494,13 @@ class HandlerDialog(QDialog):
            authors_text = ", ".join(self.book_metadata["authors"])
            html_content += f"<p style='text-align: center; font-style: italic;'>By {authors_text}</p>"

+        if self.book_metadata["publisher"] or self.book_metadata.get("publication_year"):
+            pub_info = []
            if self.book_metadata["publisher"]:
-            html_content += f"<p style='text-align: center;'>Published by {self.book_metadata['publisher']}</p>"
+                pub_info.append(f"Published by {self.book_metadata['publisher']}")
+            if self.book_metadata.get("publication_year"):
+                pub_info.append(f"Year: {self.book_metadata['publication_year']}")
+            html_content += f"<p style='text-align: center;'>{' | '.join(pub_info)}</p>"

        html_content += "<hr/>"

@@ -1512,24 +1522,51 @@ class HandlerDialog(QDialog):
            "description": None,
            "cover_image": None,
            "publisher": None,
+            "publication_year": None,
        }

        if self.file_type == "epub":
+            try:
                title_items = self.book.get_metadata("DC", "title")
-            if title_items:
+                if title_items and len(title_items) > 0:
                    metadata["title"] = title_items[0][0]
+            except Exception as e:
+                logging.warning(f"Error extracting title metadata: {e}")

+            try:
                author_items = self.book.get_metadata("DC", "creator")
                if author_items:
-                metadata["authors"] = [author[0] for author in author_items]
+                    metadata["authors"] = [author[0] for author in author_items if len(author) > 0]
+            except Exception as e:
+                logging.warning(f"Error extracting author metadata: {e}")

+            try:
                desc_items = self.book.get_metadata("DC", "description")
-            if desc_items:
+                if desc_items and len(desc_items) > 0:
                    metadata["description"] = desc_items[0][0]
+            except Exception as e:
+                logging.warning(f"Error extracting description metadata: {e}")

+            try:
                publisher_items = self.book.get_metadata("DC", "publisher")
-            if publisher_items:
+                if publisher_items and len(publisher_items) > 0:
                    metadata["publisher"] = publisher_items[0][0]
+            except Exception as e:
+                logging.warning(f"Error extracting publisher metadata: {e}")
+                
+            # Try to extract publication year
+            try:
+                date_items = self.book.get_metadata("DC", "date")
+                if date_items and len(date_items) > 0:
+                    date_str = date_items[0][0]
+                    # Try to extract just the year from the date string
+                    year_match = re.search(r'\b(19|20)\d{2}\b', date_str)
+                    if year_match:
+                        metadata["publication_year"] = year_match.group(0)
+                    else:
+                        metadata["publication_year"] = date_str
+            except Exception as e:
+                logging.warning(f"Error extracting publication date metadata: {e}")

            for item in self.book.get_items_of_type(ebooklib.ITEM_COVER):
                metadata["cover_image"] = item.get_content()
@@ -1560,6 +1597,18 @@ class HandlerDialog(QDialog):

                metadata["publisher"] = pdf_info.get("creator", None)
                
+                # Try to extract publication date from PDF metadata
+                if "creationDate" in pdf_info:
+                    date_str = pdf_info["creationDate"]
+                    year_match = re.search(r'D:(\d{4})', date_str)
+                    if year_match:
+                        metadata["publication_year"] = year_match.group(1)
+                elif "modDate" in pdf_info:
+                    date_str = pdf_info["modDate"]
+                    year_match = re.search(r'D:(\d{4})', date_str)
+                    if year_match:
+                        metadata["publication_year"] = year_match.group(1)
+
            if len(self.pdf_doc) > 0:
                try:
                    pix = self.pdf_doc[0].get_pixmap(matrix=fitz.Matrix(2, 2))
@@ -1575,10 +1624,45 @@ class HandlerDialog(QDialog):
        else:
            return self._get_pdf_selected_text()

+    def _format_metadata_tags(self):
+        """Format metadata tags for insertion at the beginning of the text"""
+        import datetime
+        
+        metadata = self.book_metadata
+        filename = os.path.splitext(os.path.basename(self.book_path))[0]
+        current_year = str(datetime.datetime.now().year)
+        
+        # Get values with fallbacks
+        title = metadata.get("title") or filename
+        authors = metadata.get("authors") or ["Unknown"]
+        authors_text = ", ".join(authors)
+        album_artist = authors_text or "Unknown"
+        year = metadata.get("publication_year") or current_year  # Use publication year if available
+        
+        # Count chapters/pages
+        total_chapters = len(self.checked_chapters)
+        chapter_text = f"{total_chapters} {'Chapters' if self.file_type == 'epub' else 'Pages'}"
+        
+        # Format metadata tags
+        metadata_tags = [
+            f"<<METADATA_TITLE:{title}>>",
+            f"<<METADATA_ARTIST:{authors_text}>>",
+            f"<<METADATA_ALBUM:{title} ({chapter_text})>>",
+            f"<<METADATA_YEAR:{year}>>",
+            f"<<METADATA_ALBUM_ARTIST:{album_artist}>>",
+            f"<<METADATA_COMPOSER:Narrator>>",
+            f"<<METADATA_GENRE:Audiobook>>"
+        ]
+        
+        return "\n".join(metadata_tags)
+
    def _get_epub_selected_text(self):
        all_checked_identifiers = set()
        chapter_texts = []

+        # Add metadata tags at the beginning
+        metadata_tags = self._format_metadata_tags()
+        
        item_order_counter = 0
        ordered_checked_items = []

@@ -1603,7 +1687,7 @@ class HandlerDialog(QDialog):
                marker = f"<<CHAPTER_MARKER:{title}>>"
                chapter_texts.append(marker + "\n" + text)

-        full_text = "\n\n".join(chapter_texts)
+        full_text = metadata_tags + "\n\n" + "\n\n".join(chapter_texts)
        return full_text, all_checked_identifiers

    def _get_pdf_selected_text(self):
@@ -1612,6 +1696,9 @@ class HandlerDialog(QDialog):
        section_titles = []
        all_content = []

+        # Add metadata tags at the beginning
+        metadata_tags = self._format_metadata_tags()
+
        pdf_has_no_bookmarks = (
            hasattr(self, "has_pdf_bookmarks") and not self.has_pdf_bookmarks
        )
@@ -1636,7 +1723,7 @@ class HandlerDialog(QDialog):
                    if text:
                        all_content.append(text)
                        included_text_ids.add(page_id)
-            return "\n\n".join(all_content), all_checked_identifiers
+            return metadata_tags + "\n\n" + "\n\n".join(all_content), all_checked_identifiers

        iterator = QTreeWidgetItemIterator(self.treeWidget)
        while iterator.value():
@@ -1694,7 +1781,7 @@ class HandlerDialog(QDialog):
                        included_text_ids.add(identifier)
            iterator += 1

-        return "\n\n".join([t[1] for t in section_titles]), all_checked_identifiers
+        return metadata_tags + "\n\n" + "\n\n".join([t[1] for t in section_titles]), all_checked_identifiers

    def on_save_chapters_changed(self, state):
        self.save_chapters_separately = bool(state)
@@ -1705,6 +1792,10 @@ class HandlerDialog(QDialog):
        self.merge_chapters_at_end = bool(state)
        HandlerDialog._merge_chapters_at_end = self.merge_chapters_at_end

+    def on_save_as_project_changed(self, state):
+        self.save_as_project = bool(state)
+        HandlerDialog._save_as_project = self.save_as_project
+
    def get_save_chapters_separately(self):
        return (
            self.save_chapters_separately
@@ -1715,6 +1806,9 @@ class HandlerDialog(QDialog):
    def get_merge_chapters_at_end(self):
        return self.merge_chapters_at_end

+    def get_save_as_project(self):
+        return self.save_as_project
+
    def on_tree_context_menu(self, pos):
        item = self.treeWidget.itemAt(pos)
        if (
@@ -4,13 +4,18 @@ import tempfile
 import time
 import chardet
 import charset_normalizer
+import hashlib  # For generating unique cache filenames
 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 hf_tracker
+import static_ffmpeg
+import threading  # for efficient waiting
+import subprocess


 def get_sample_voice_text(lang_code):
@@ -128,6 +133,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
@@ -151,11 +157,163 @@ class ConversionThread(QThread):
        self.use_gpu = use_gpu  # Store the GPU setting
        self.max_subtitle_words = 50  # Default value, will be overridden from GUI

+    def _stream_audio_in_chunks(self, segments, process_func, progress_prefix="Processing"):
+        """
+        Process audio segments in memory-efficient chunks
+        
+        Args:
+            segments: List of audio segments to process
+            process_func: Function that takes (segment_bytes, is_last) and processes a chunk
+            progress_prefix: Prefix for progress messages
+            
+        Returns:
+            Total samples processed
+        """
+        # Calculate total size for progress reporting
+        total_samples = sum(len(segment) for segment in segments)
+        samples_processed = 0
+
+        self.log_updated.emit(f"\n{progress_prefix} segments...")
+        
+        # Stream each segment individually
+        for i, segment in enumerate(segments):
+            try:
+                # Handle both NumPy arrays and PyTorch tensors
+                if hasattr(segment, 'astype'):
+                    segment_bytes = segment.astype("float32").tobytes()
+                else:
+                    segment_bytes = segment.cpu().numpy().astype("float32").tobytes()
+                is_last = (i == len(segments) - 1)
+                
+                # Update progress periodically - skip if there's only one segment
+                if (i % 20 == 0 or is_last) and len(segments) > 1:
+                    progress_percent = int((samples_processed / total_samples) * 100)
+                    self.log_updated.emit(f"{progress_prefix} segment {i+1}/{len(segments)} ({progress_percent}% complete)")
+                
+                # Process this segment
+                process_func(segment_bytes, is_last)
+                
+                # Update samples processed
+                samples_processed += len(segment)
+                
+                # Clear segment bytes from memory
+                del segment_bytes
+            except Exception as e:
+                self.log_updated.emit(f"Error processing segment {i}: {str(e)}")
+                raise
+                
+        return samples_processed
+
+    def _process_audio_segments(self, audio_segments, output_path, output_format, use_ffmpeg=False, ffmpeg_args=None):
+        """
+        Process audio segments to a target format with memory-efficient handling
+        
+        Args:
+            audio_segments: List of audio segments to process
+            output_path: Path for output file
+            output_format: Format of output (wav, mp3, flac, opus, m4b)
+            use_ffmpeg: Whether to use FFmpeg instead of soundfile
+            ffmpeg_args: Optional additional FFmpeg arguments when use_ffmpeg=True
+            
+        Returns:
+            Tuple of (success, output_path)
+        """
+        self.log_updated.emit(f"\nProcessing audio data to {output_format.upper()}...")
+        segments_count = len(audio_segments)
+        
+        # Handle direct streaming for WAV (the only format supporting append mode)
+        if output_format == "wav" and not use_ffmpeg:
+            try:
+                # Write first segment
+                sf.write(output_path, audio_segments[0], 24000, format="wav")
+                
+                # Append remaining segments
+                for i, segment in enumerate(audio_segments[1:], 1):
+                    with sf.SoundFile(output_path, mode='r+') as f:
+                        f.seek(0, sf.SEEK_END)
+                        f.write(segment)
+                return True, output_path
+            except Exception as e:
+                self.log_updated.emit((f"Error writing WAV file: {str(e)}", "red"))
+                return False, None
+        
+        # For formats requiring FFmpeg (opus, m4b) or when explicitly requested
+        if use_ffmpeg or output_format in ["opus", "m4b"]:
+            static_ffmpeg.add_paths()
+            
+            # Basic FFmpeg command
+            cmd = [
+                "ffmpeg", "-y",
+                "-thread_queue_size", "32768",
+                "-f", "f32le",
+                "-ar", "24000",
+                "-ac", "1",
+                "-i", "pipe:0"
+            ]
+            
+            # Add custom FFmpeg arguments if provided
+            if ffmpeg_args:
+                cmd.extend(ffmpeg_args)
+            else:
+                # Default codec settings based on format
+                if output_format == "opus":
+                    cmd.extend(["-c:a", "libopus", "-b:a", "24000"])
+                elif output_format == "mp3":
+                    cmd.extend(["-c:a", "libmp3lame", "-q:a", "2"])
+                elif output_format == "flac":
+                    cmd.extend(["-c:a", "flac", "-compression_level", "8"])
+                else:
+                    cmd.extend(["-c:a", "aac", "-q:a", "2"])
+            
+            # Add output path
+            cmd.append(output_path)
+            
+            # Create process
+            proc = create_process(cmd, stdin=subprocess.PIPE, text=False)
+            
+            # Process segments
+            try:
+                # Use the unified streaming function
+                def process_chunk(chunk_bytes, is_last):
+                    proc.stdin.write(chunk_bytes)
+                
+                self._stream_audio_in_chunks(audio_segments, process_chunk, 
+                                          progress_prefix=f"Processing {output_format.upper()}")
+                
+                # Close stdin and wait for process to complete
+                proc.stdin.close()
+                if proc.wait() != 0:
+                    self.log_updated.emit((f"{output_format.upper()} conversion failed.", "red"))
+                    return False, None
+                
+                return True, output_path
+                
+            except Exception as e:
+                self.log_updated.emit((f"Error during {output_format.upper()} conversion: {str(e)}", "red"))
+                proc.stdin.close()
+                try:
+                    proc.terminate()
+                except:
+                    pass
+                return False, None
+        
+        # For formats supported by soundfile (mp3, flac)
+        else:
+            try:
+                with sf.SoundFile(output_path, 'w', samplerate=24000, channels=1, format=output_format) as f:
+                    for i, segment in enumerate(audio_segments):
+                        f.write(segment)
+                return True, output_path
+            except Exception as e:
+                self.log_updated.emit((f"Error processing {output_format.upper()} file: {str(e)}", "red"))
+                return False, None
+
    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:
+            hf_tracker.set_log_callback(lambda msg: self.log_updated.emit(msg))
            # Show configuration
            self.log_updated.emit("Configuration:")
            # Use display_path for logs if available, otherwise use the actual file name
@@ -175,6 +333,7 @@ class ConversionThread(QThread):
            self.log_updated.emit(f"- Speed: {self.speed}")
            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"- Subtitle format: {getattr(self, 'subtitle_format', 'srt')}")
            self.log_updated.emit(f"- Save option: {self.save_option}")
            if self.replace_single_newlines:
                self.log_updated.emit(f"- Replace single newlines: Yes")
@@ -192,6 +351,9 @@ class ConversionThread(QThread):
                    self.log_updated.emit(
                        f"- Merge chapters at the end: {'Yes' if merge_at_end else 'No'}"
                    )
+                    # Display the separate chapters format if it's set
+                    separate_format = getattr(self, 'separate_chapters_format', 'wav')
+                    self.log_updated.emit(f"- Separate chapters format: {separate_format}")

            if self.save_option == "Choose output folder":
                self.log_updated.emit(
@@ -217,11 +379,21 @@ class ConversionThread(QThread):
            # Clean up text using utility function
            text = clean_text(text)
            
+            # Remove metadata markers from the text to be processed
+            metadata_pattern = r"<<METADATA_[^:]+:[^>]*>>"
+            text = re.sub(metadata_pattern, "", text)
+
            # --- Chapter splitting logic ---
            chapter_pattern = r"<<CHAPTER_MARKER:(.*?)>>"
            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 = (
@@ -252,18 +424,12 @@ class ConversionThread(QThread):
                and not self.chapter_options_set
            ):

-                self.waiting_for_user_input = True
-                # Emit signal to main thread to show dialog
+                # Emit signal to main thread and wait
                self.chapters_detected.emit(total_chapters)
-
-                # Wait for chapter options to be set
-                while self.waiting_for_user_input and not self.cancel_requested:
-                    time.sleep(0.1)
-
+                self._chapter_options_event.wait()
                if self.cancel_requested:
                    self.conversion_finished.emit("Cancelled", None)
                    return
-
                self.chapter_options_set = True

            # Log all detected chapters at the beginning
@@ -339,6 +505,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:
@@ -354,6 +526,10 @@ 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+"

@@ -467,6 +643,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
@@ -474,32 +653,53 @@ class ConversionThread(QThread):
                    and chapters_out_dir
                    and chapter_audio_segments
                ):
-                    # Sanitize chapter name for use in filenames
-                    sanitized_chapter_name = re.sub(r"[^\w\-\. ]", "_", chapter_name)
-                    sanitized_chapter_name = re.sub(
-                        r"_+", "_", sanitized_chapter_name
-                    )  # Replace multiple underscores with one
-                    chapter_filename = f"{chapter_idx:02d}_{sanitized_chapter_name}"

-                    # Concatenate chapter audio and save
-                    chapter_audio = self.np.concatenate(chapter_audio_segments)
+                    # strip any non‐alphanumeric or space/dash
+                    sanitized = re.sub(r"[^\w\s\-]", "", chapter_name)
+                    # collapse spaces or dashes to single underscore
+                    sanitized = re.sub(r"[\s\-]+", "_", sanitized).strip("_")
+                    # enforce max length
+                    MAX_LEN = 80
+                    if len(sanitized) > MAX_LEN:
+                        # Find last word boundary before limit
+                        pos = sanitized[:MAX_LEN].rfind("_")
+                        # Use word boundary if found, otherwise use hard limit
+                        sanitized = sanitized[:pos if pos > 0 else MAX_LEN].rstrip("_")
+                    chapter_filename = f"{chapter_idx:02d}_{sanitized}"
+
+                    # Use separate_chapters_format
+                    separate_format = getattr(self, 'separate_chapters_format', 'wav')
+                    
                    chapter_out_path = os.path.join(
-                        chapters_out_dir, f"{chapter_filename}.{self.output_format}"
-                    )
-                    sf.write(
-                        chapter_out_path,
-                        chapter_audio,
-                        24000,
-                        format=self.output_format,
+                        chapters_out_dir, f"{chapter_filename}.{separate_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"
+                    # Process audio segments using the unified function
+                    success, chapter_out_path = self._process_audio_segments(
+                        chapter_audio_segments, chapter_out_path, separate_format, use_ffmpeg=(separate_format in ["opus", "m4b"])
                    )
+                    
+                    if not success:
+                        self.log_updated.emit((f"Failed to write {separate_format.upper()} file.", "red"))
+                        continue
+
+                    # Generate subtitle file for chapter if not Disabled
+                    if self.subtitle_mode != "Disabled" and chapter_subtitle_entries:
+                        subtitle_format = getattr(self, 'subtitle_format', 'srt')
+                        file_extension = 'ass' if 'ass' in subtitle_format else 'srt'
+                        chapter_subtitle_path = os.path.join(
+                            chapters_out_dir, f"{chapter_filename}.{file_extension}"
+                        )
+                        
+                        if 'ass' in subtitle_format:
+                            # Generate ASS subtitle
+                            is_centered = 'centered' in subtitle_format
+                            is_narrow = 'narrow' in subtitle_format
+                            self._write_ass_subtitle(chapter_subtitle_path, chapter_subtitle_entries, is_centered, is_narrow)
+                        else:
+                            # Generate SRT subtitle (default)
                            with open(
-                            chapter_srt_path, "w", encoding="utf-8", errors="replace"
+                                chapter_subtitle_path, "w", encoding="utf-8", errors="replace"
                            ) as srt_file:
                                for i, (start, end, text) in enumerate(
                                    chapter_subtitle_entries, 1
@@ -510,7 +710,7 @@ class ConversionThread(QThread):

                        self.log_updated.emit(
                            (
-                                f"\nChapter {chapter_idx} saved to: {chapter_out_path}\n\nSubtitle saved to: {chapter_srt_path}",
+                                f"\nChapter {chapter_idx} saved to: {chapter_out_path}\n\nSubtitle saved to: {chapter_subtitle_path}",
                                "green",
                            )
                        )
@@ -531,34 +731,72 @@ 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)
+                self.log_updated.emit("\nFinalizing audio file...")
+
                out_dir = parent_dir
-                # Use the same suffix as above
-                out_filename = f"{base_name}{suffix}.{self.output_format}"
-                out_path = os.path.join(out_dir, out_filename)
-                srt_path = os.path.splitext(out_path)[0] + ".srt"
-                sf.write(out_path, audio, 24000, format=self.output_format)
+                base_filepath_no_ext = os.path.join(out_dir, f"{base_name}{suffix}")
+
+                final_out_path = None
+                
+                # Use dedicated chapter processing for M4B when we have chapters
+                if intended_output_format == "m4b":
+                    self.log_updated.emit("\nGenerating audio with chapters...")
+                    final_out_path = self._generate_m4b_with_chapters(
+                        audio_segments, chapters_time, base_filepath_no_ext
+                    )
+                else:
+                    # Process audio segments using the unified function
+                    success, final_out_path = self._process_audio_segments(
+                        audio_segments, f"{base_filepath_no_ext}.{intended_output_format}", 
+                        intended_output_format, 
+                        use_ffmpeg=(intended_output_format in ["opus", "m4b"])
+                    )
+                    
+                    if not success:
+                        final_out_path = None
+                
+                if not final_out_path:
+                    self.log_updated.emit(("Audio generation failed.", "red"))
+                    self.conversion_finished.emit(("Audio generation failed.", "red"), None)
+                    return
+
+                # Subtitle and final message logic
+                if final_out_path:
                    if self.subtitle_mode != "Disabled":
-                    with open(
-                        srt_path, "w", encoding="utf-8", errors="replace"
-                    ) as srt_file:
+                        subtitle_format = getattr(self, 'subtitle_format', 'srt')
+                        file_extension = 'ass' if 'ass' in subtitle_format else 'srt'
+                        subtitle_path = os.path.splitext(final_out_path)[0] + f".{file_extension}"
+                        
+                        if 'ass' in subtitle_format:
+                            # Generate ASS subtitle with optional centering and margin
+                            is_centered = 'centered' in subtitle_format
+                            is_narrow = 'narrow' in subtitle_format
+                            self._write_ass_subtitle(subtitle_path, subtitle_entries, is_centered, is_narrow)
+                        else:
+                            # Generate SRT subtitle (default)
+                            with open(subtitle_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: {out_path}\n\nSubtitle saved to: {srt_path}",
+                                f"\nAudiobook saved to: {final_out_path}\n\nSubtitle saved to: {subtitle_path}",
                                "green",
                            ),
-                        out_path,
+                            final_out_path,
                        )
                    else:
                        self.conversion_finished.emit(
-                        (f"Audiobook saved to: {out_path}", "green"), out_path
+                            (f"\nAudiobook saved to: {final_out_path}", "green"), final_out_path
                        )
+                else:
+                    self.log_updated.emit(("Audio generation failed (final_out_path was not set).", "red"))
+                    self.conversion_finished.emit(("Audio generation failed.", "red"), None)
            elif audio_segments and not merge_chapters:
                self.conversion_finished.emit(
                    (
@@ -579,6 +817,183 @@ 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_segments, chapters_time, base_filepath_no_ext):
+        """Generate M4B file with chapters from audio segments"""
+        final_wav_path = f"{base_filepath_no_ext}.wav"
+        output_m4b_path = f"{base_filepath_no_ext}.m4b"
+        chapters_info_path = f"{base_filepath_no_ext}_chapters.txt"
+        
+        # Early check for single/no chapter case
+        if not chapters_time or len(chapters_time) <= 1:
+            self.log_updated.emit(
+                (
+                    "\nFile contains only one chapter or no chapters were detected. Audio will be saved as a standard .wav file instead.",
+                    "red",
+                )
+            )
+            # Use the established unified method to create a WAV file
+            success, wav_path = self._process_audio_segments(
+                audio_segments, final_wav_path, "wav", use_ffmpeg=False
+            )
+            if success:
+                return wav_path
+            else:
+                self.log_updated.emit((f"\nFailed to save single/no chapter audio as WAV", "red"))
+                return None
+
+        try:
+            # Write chapter metadata file
+            with open(chapters_info_path, "w", encoding="utf-8") as f:
+                f.write(";FFMETADATA1\n")
+                for chapter in chapters_time:
+                    chapter_title = chapter['chapter'].replace('=', '\\=')
+                    f.write(f"[CHAPTER]\n")
+                    f.write(f"TIMEBASE=1/1000\n")
+                    f.write(f"START={int(chapter['start']*1000)}\n")
+                    f.write(f"END={int(chapter['end']*1000)}\n")
+                    f.write(f"title={chapter_title}\n\n")
+            
+            # For M4B with chapters, we need to use input file for chapter information
+            static_ffmpeg.add_paths()
+            metadata_options = self._extract_and_add_metadata_tags_to_ffmpeg_cmd()
+            
+            # Use pipe-based approach for audio input with special args for M4B chapters
+            ffmpeg_args = [
+                "-i", chapters_info_path,
+                "-map", "0:a",
+                "-map_metadata", "1", 
+                "-map_chapters", "1",
+                *metadata_options,
+                "-c:a", "aac",
+                "-q:a", "2", # Quality-based VBR for better quality control
+                "-movflags", "+faststart+use_metadata_tags",  # Added for better compatibility
+            ]
+
+            # Use the established unified method with M4B-specific args
+            success, out_path = self._process_audio_segments(
+                audio_segments, output_m4b_path, "m4b", use_ffmpeg=True, ffmpeg_args=ffmpeg_args
+            )
+            
+            # Clean up the temporary chapter metadata file
+            if os.path.exists(chapters_info_path):
+                try:
+                    os.remove(chapters_info_path)
+                except Exception as e:
+                    self.log_updated.emit((f"Warning: Could not delete chapters file: {e}", "orange"))
+
+            if success:
+                return out_path
+            
+            # If M4B generation failed, fallback to WAV
+            self.log_updated.emit((f"M4B conversion failed. Falling back to WAV.\n", "red"))
+            success, wav_path = self._process_audio_segments(
+                audio_segments, final_wav_path, "wav", use_ffmpeg=False
+            )
+            if success:
+                return wav_path
+            else:
+                self.log_updated.emit((f"Failed to write WAV file as fallback.", "red"))
+                return None
+
+        except Exception as e:
+            # General error during M4B generation - create WAV file directly as final output
+            self.log_updated.emit((f"Error during M4B generation: {str(e)}.\n\nFalling back to WAV.\n", "red"))
+            
+            # Use the established unified method to create a WAV file as fallback
+            success, wav_path = self._process_audio_segments(
+                audio_segments, final_wav_path, "wav", use_ffmpeg=False
+            )
+            
+            # Clean up temp files
+            if os.path.exists(chapters_info_path):
+                try:
+                    os.remove(chapters_info_path)
+                except Exception:
+                    pass
+                
+            if success:
+                return wav_path
+            else:
+                self.log_updated.emit((f"Critical error: Failed to save WAV fallback", "red"))
+                return None
+
+    def _extract_and_add_metadata_tags_to_ffmpeg_cmd(self):
+        """Extract metadata tags from text content and add them to ffmpeg command"""
+        metadata_options = []
+        
+        # Get the input text (either direct or from file)
+        text = ""
+        if self.is_direct_text:
+            text = self.file_name
+        else:
+            try:
+                encoding = detect_encoding(self.file_name)
+                with open(self.file_name, "r", encoding=encoding, errors="replace") as file:
+                    text = file.read()
+            except Exception as e:
+                self.log_updated.emit(f"Warning: Could not read file for metadata extraction: {e}")
+                return []
+                
+        # Extract metadata tags using regex
+        title_match = re.search(r"<<METADATA_TITLE:([^>]*)>>", text)
+        artist_match = re.search(r"<<METADATA_ARTIST:([^>]*)>>", text) 
+        album_match = re.search(r"<<METADATA_ALBUM:([^>]*)>>", text)
+        year_match = re.search(r"<<METADATA_YEAR:([^>]*)>>", text)
+        album_artist_match = re.search(r"<<METADATA_ALBUM_ARTIST:([^>]*)>>", text)
+        composer_match = re.search(r"<<METADATA_COMPOSER:([^>]*)>>", text)
+        genre_match = re.search(r"<<METADATA_GENRE:([^>]*)>>", text)
+        
+        # Use display path or filename as fallback for title
+        filename = os.path.splitext(os.path.basename(self.display_path if self.display_path else self.file_name))[0]
+        
+        if title_match:
+            metadata_options.extend(["-metadata", f"title={title_match.group(1)}"])
+        else:
+            metadata_options.extend(["-metadata", f"title={filename}"])
+            
+        # Add artist metadata
+        if artist_match:
+            metadata_options.extend(["-metadata", f"artist={artist_match.group(1)}"])
+        else:
+            metadata_options.extend(["-metadata", f"artist=Unknown"])
+            
+        # Add album metadata
+        if album_match:
+            metadata_options.extend(["-metadata", f"album={album_match.group(1)}"])
+        else:
+            metadata_options.extend(["-metadata", f"album={filename}"])
+            
+        # Add year metadata
+        if year_match:
+            metadata_options.extend(["-metadata", f"date={year_match.group(1)}"])
+        else:
+            # Use current year if year is not specified
+            import datetime
+            current_year = datetime.datetime.now().year
+            metadata_options.extend(["-metadata", f"date={current_year}"])
+
+        # Add album artist metadata
+        if album_artist_match:
+            metadata_options.extend(["-metadata", f"album_artist={album_artist_match.group(1)}"])
+        else:
+            metadata_options.extend(["-metadata", f"album_artist=Unknown"])
+
+        # Add composer metadata
+        if composer_match:
+            metadata_options.extend(["-metadata", f"composer={composer_match.group(1)}"])
+        else:
+            metadata_options.extend(["-metadata", f"composer=Narrator"])
+
+        # Add genre metadata
+        if genre_match:
+            metadata_options.extend(["-metadata", f"genre={genre_match.group(1)}"])
+        else:
+            metadata_options.extend(["-metadata", f"genre=Audiobook"])
+            
+        # Add these to ffmpeg command
+        return metadata_options

    def _srt_time(self, t):
        """Helper function to format time for SRT files"""
@@ -588,6 +1003,14 @@ class ConversionThread(QThread):
        ms = int((t - int(t)) * 1000)
        return f"{h:02}:{m:02}:{s:02},{ms:03}"
        
+    def _ass_time(self, t):
+        """Helper function to format time for ASS files"""
+        h = int(t // 3600)
+        m = int((t % 3600) // 60)
+        s = int(t % 60)
+        cs = int((t - int(t)) * 100)  # Centiseconds for ASS format
+        return f"{h}:{m:02}:{s:02}.{cs:02}"
+
    def _process_subtitle_tokens(
        self, tokens_with_timestamps, subtitle_entries, max_subtitle_words
    ):
@@ -674,6 +1097,30 @@ class ConversionThread(QThread):
                        (group[0]["start"], group[-1]["end"], text.strip())
                    )

+    def _write_ass_subtitle(self, file_path, subtitle_entries, is_centered=False, is_narrow=False):
+        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+            # Minimal ASS header
+            f.write("[Script Info]\n")
+            f.write("Title: Generated by Abogen\n")
+            f.write("ScriptType: v4.00+\n\n")
+            
+            # Only events section, use override tags for positioning
+            f.write("[Events]\n")
+            f.write("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
+            
+            # Set margin based on is_narrow parameter
+            margin = "90" if is_narrow else ""
+            alignment_tag = ""
+            if is_centered:
+                alignment = 5
+                alignment_tag = f"{{\\an{alignment}}}"
+
+            # Write each subtitle with override tag for alignment and margins
+            for i, (start, end, text) in enumerate(subtitle_entries, 1):
+                start_time = self._ass_time(start)
+                end_time = self._ass_time(end)
+                f.write(f"Dialogue: 0,{start_time},{end_time},Default,,{margin},{margin},0,,{alignment_tag}{text}\n")
+
    def cancel(self):
        self.cancel_requested = True
        self.waiting_for_user_input = (
@@ -703,10 +1150,31 @@ class VoicePreviewThread(QThread):
        self.speed = speed
        self.use_gpu = use_gpu
        
+        # Cache location for preview audio
+        self.cache_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME, "preview_cache")
+        os.makedirs(self.cache_dir, exist_ok=True)
+        
+        # Calculate cache path
+        self.cache_path = self._get_cache_path()
+
+    def _get_cache_path(self):
+        """Generate a unique filename for the voice with its parameters"""
+        # For a voice formula, use a hash of the formula
+        if "*" in self.voice:
+            voice_id = f"voice_formula_{hashlib.md5(self.voice.encode()).hexdigest()[:8]}"
+        else:
+            voice_id = self.voice
+            
+        # Create a unique filename based on voice_id, language, and speed
+        filename = f"{voice_id}_{self.lang_code}_{self.speed:.2f}.wav"
+        return os.path.join(self.cache_dir, filename)
+
    def run(self):
        print(
            f"\nVoice: {self.voice}\nLanguage: {self.lang_code}\nSpeed: {self.speed}\nGPU: {self.use_gpu}\n"
        )
+        
+        # Generate the preview and save to cache
        try:
            device = "cuda" if self.use_gpu else "cpu"
            tts = self.kpipeline_class(
@@ -725,15 +1193,9 @@ class VoicePreviewThread(QThread):
                audio_segments.append(result.audio)
            if audio_segments:
                audio = self.np_module.concatenate(audio_segments)
-                # Create temp wav file in a folder in the system temp directory
-                temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
-                os.makedirs(temp_dir, exist_ok=True)
-                fd, temp_path = tempfile.mkstemp(
-                    prefix="abogen_", suffix=".wav", dir=temp_dir
-                )
-                os.close(fd)
-                sf.write(temp_path, audio, 24000)
-                self.temp_wav = temp_path
+                # Save directly to the cache path
+                sf.write(self.cache_path, audio, 24000)
+                self.temp_wav = self.cache_path
            self.finished.emit()
        except Exception as e:
            self.error.emit(f"Voice preview error: {str(e)}")
@@ -746,6 +1208,7 @@ class PlayAudioThread(QThread):
    def __init__(self, wav_path, parent=None):
        super().__init__(parent)
        self.wav_path = wav_path
+        self.is_canceled = False

    def run(self):
        try:
@@ -755,10 +1218,37 @@ class PlayAudioThread(QThread):
            pygame.mixer.init()
            pygame.mixer.music.load(self.wav_path)
            pygame.mixer.music.play()
-            # Wait until playback is finished
-            while pygame.mixer.music.get_busy():
-                _time.sleep(0.1)
+            # Wait until playback is finished or canceled
+            while pygame.mixer.music.get_busy() and not self.is_canceled:
+                _time.sleep(0.2)
+                
+            # Make sure to clean up regardless of how we exited the loop
+            try:
+                pygame.mixer.music.stop()
                pygame.mixer.music.unload()
+                pygame.mixer.quit()  # Quit the mixer
+            except Exception:
+                # Ignore any errors during cleanup
+                pass
+                
            self.finished.emit()
        except Exception as e:
+            # Handle initialization errors separately to give better error messages
+            if "mixer not initialized" in str(e):
+                self.error.emit("Audio playback error: The audio system was not properly initialized")
+            else:
                self.error.emit(f"Audio playback error: {str(e)}")
+            
+    def stop(self):
+        """Safely stop playback"""
+        self.is_canceled = True
+        # Try to stop pygame if it's running, but catch all exceptions
+        try:
+            import pygame
+            if pygame.mixer.get_init():
+                if pygame.mixer.music.get_busy():
+                    pygame.mixer.music.stop()
+                pygame.mixer.music.unload()
+        except Exception:
+            # Ignore all errors when stopping since mixer might not be initialized
+            pass
@@ -4,6 +4,8 @@ import tempfile
 import platform
 import base64
 import re
+import hf_tracker
+import hashlib  # Added for cache path generation
 from PyQt5.QtWidgets import (
    QApplication,
    QWidget,
@@ -23,6 +25,7 @@ from PyQt5.QtWidgets import (
    QCheckBox,
    QMenu,
    QAction,
+    QActionGroup,
 )
 from PyQt5.QtCore import (
    Qt,
@@ -71,7 +74,6 @@ from constants import (
 )
 from threading import Thread
 from voice_formula_gui import VoiceFormulaDialog
-from platformdirs import user_desktop_dir
 from voice_profiles import load_profiles

 # Import ctypes for Windows-specific taskbar icon
@@ -79,6 +81,13 @@ if platform.system() == "Windows":
    import ctypes


+class ShowWarningSignalEmitter(QObject):  # New class to handle signal emission
+    show_warning_signal = pyqtSignal(str, str)
+
+    def emit(self, title, message):
+        self.show_warning_signal.emit(title, message)
+
+
 class ThreadSafeLogSignal(QObject):
    log_signal = pyqtSignal(object)

@@ -95,9 +104,15 @@ class IconProvider(QFileIconProvider):


 class InputBox(QLabel):
-    LABEL_CSS = """QLabel { border:2px dashed #aaa; border-radius:5px; padding:20px; background:#f5f9fc; min-height:100px; } QLabel:hover { background:#e5f1fa; border-color:#6ab0de; }"""
-    LABEL_CSS_ACTIVE = """QLabel { border:2px dashed #42ad4a; border-radius:5px; padding:20px; background:#e6f7e6;min-height:100px; } QLabel:hover { background:#e5f1fa; border-color:#6ab0de; }"""
-    LABEL_CSS_ERROR = """QLabel { border:2px dashed #e74c3c; border-radius:5px; padding:20px; background:#ffeaea; min-height:100px; color:#c0392b; } QLabel:hover { background:#ffeaea; border-color:#e74c3c; }"""
+    # Define CSS styles as class constants
+    STYLE_DEFAULT = "border:2px dashed #aaa; border-radius:5px; padding:20px; background:rgba(0, 102, 255, 0.05); min-height:100px;"
+    STYLE_DEFAULT_HOVER = "background:rgba(0, 102, 255, 0.1); border-color:#6ab0de;"
+    
+    STYLE_ACTIVE = "border:2px dashed #42ad4a; border-radius:5px; padding:20px; background:rgba(66, 173, 73, 0.1); min-height:100px;"
+    STYLE_ACTIVE_HOVER = "background:rgba(66, 173, 73, 0.15); border-color:#42ad4a;"
+    
+    STYLE_ERROR = "border:2px dashed #e74c3c; border-radius:5px; padding:20px; background:rgba(232, 78, 60, 0.10); min-height:100px; color:#c0392b;" 
+    STYLE_ERROR_HOVER = "background:rgba(232, 78, 60, 0.15); border-color:#e74c3c;"

    def __init__(self, parent=None):
        super().__init__(parent)
@@ -106,7 +121,7 @@ class InputBox(QLabel):
        self.setText(
            "Drag and drop your file here or click to browse.\n(.txt, .epub, .pdf)"
        )
-        self.setStyleSheet(self.LABEL_CSS)
+        self.setStyleSheet(f"QLabel {{ {self.STYLE_DEFAULT} }} QLabel:hover {{ {self.STYLE_DEFAULT_HOVER} }}")
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.setCursor(Qt.PointingHandCursor)
        self.clear_btn = QPushButton("✕", self)
@@ -129,6 +144,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
@@ -139,6 +161,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
@@ -201,7 +228,7 @@ class InputBox(QLabel):
        )
        # Set fixed width to force wrapping
        self.setWordWrap(True)
-        self.setStyleSheet(self.LABEL_CSS_ACTIVE)
+        self.setStyleSheet(f"QLabel {{ {self.STYLE_ACTIVE} }} QLabel:hover {{ {self.STYLE_ACTIVE_HOVER} }}")
        self.clear_btn.show()
        is_document = self.window().selected_file_type in ["epub", "pdf"]
        self.chapters_btn.setVisible(is_document)
@@ -228,10 +255,11 @@ 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)
-        self.setStyleSheet(self.LABEL_CSS_ERROR)
+        self.setStyleSheet(f"QLabel {{ {self.STYLE_ERROR} }} QLabel:hover {{ {self.STYLE_ERROR_HOVER} }}")
        # Show textbox button in error state as well
        self.textbox_btn.show()

@@ -243,13 +271,14 @@ class InputBox(QLabel):
        self.setText(
            "Drag and drop your file here or click to browse.\n(.txt, .epub, .pdf)"
        )
-        self.setStyleSheet(self.LABEL_CSS)
+        self.setStyleSheet(f"QLabel {{ {self.STYLE_DEFAULT} }} QLabel:hover {{ {self.STYLE_DEFAULT_HOVER} }}")
        self.clear_btn.hide()
        self.chapters_btn.hide()
        self.chapters_btn.setText("Chapters")  # Reset text
        # 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"]:
@@ -290,8 +319,8 @@ class InputBox(QLabel):
                )
                win.selected_book_path = file_path
                win.open_book_file(
-                    file_path
-                )  # This will handle the dialog and setting file info
+                    file_path  # This will handle the dialog and setting file info
+                )
                event.acceptProposedAction()
            else:
                self.set_error("Please drop a .txt, .epub, or .pdf file.")
@@ -320,6 +349,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):
@@ -328,7 +368,7 @@ class TextboxDialog(QDialog):
        self.setWindowFlags(
            Qt.Window | Qt.WindowCloseButtonHint | Qt.WindowMaximizeButtonHint
        )
-        self.resize(600, 400)
+        self.resize(700, 500)

        layout = QVBoxLayout(self)

@@ -358,6 +398,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)

@@ -382,8 +427,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
@@ -444,6 +495,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):
@@ -476,6 +535,7 @@ class abogen(QWidget):
            "max_subtitle_words", 50
        )  # Default max words per subtitle
        self.selected_format = self.config.get("selected_format", "wav")
+        self.separate_chapters_format = self.config.get("separate_chapters_format", "wav")  # Format for individual chapter files
        self.use_gpu = self.config.get(
            "use_gpu", True  # Load GPU setting with default True
        )
@@ -487,6 +547,11 @@ class abogen(QWidget):
        self.log_signal = ThreadSafeLogSignal()
        self.log_signal.log_signal.connect(self._update_log_main_thread)

+        # Create warning signal emitter
+        self.warning_signal_emitter = ShowWarningSignalEmitter()
+        self.warning_signal_emitter.show_warning_signal.connect(self.show_model_download_warning)
+        hf_tracker.set_show_warning_signal_emitter(self.warning_signal_emitter)
+
        # Set application icon
        icon_path = get_resource_path("abogen.assets", "icon.ico")
        if icon_path:
@@ -538,6 +603,9 @@ class abogen(QWidget):
        if self.check_updates:
            QTimer.singleShot(1000, self.check_for_updates_startup)

+        # Set hf_tracker callbacks
+        hf_tracker.set_log_callback(self.update_log)
+
    def initUI(self):
        self.setWindowTitle(f"{PROGRAM_NAME} v{VERSION}")
        screen = QApplication.primaryScreen().geometry()
@@ -634,6 +702,7 @@ class abogen(QWidget):
        self.btn_preview.clicked.connect(self.preview_voice)
        voice_row.addWidget(self.btn_preview)
        self.preview_playing = False
+        self.play_audio_thread = None  # Keep track of audio playing thread
        voice_layout.addLayout(voice_row)
        controls_layout.addLayout(voice_layout)
        # Subtitle mode
@@ -673,10 +742,23 @@ class abogen(QWidget):
        self.format_combo.setStyleSheet(
            "QComboBox { min-height: 20px; padding: 6px 12px; }"
        )
-        format_options = ["wav", "flac", "mp3"]
-        self.format_combo.addItems(format_options)
-        self.format_combo.setCurrentText(self.selected_format)
-        self.format_combo.currentTextChanged.connect(self.on_format_changed)
+        # Add items with display labels and underlying keys
+        for key, label in [
+            ("wav", "wav"),
+            ("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
@@ -831,9 +913,7 @@ class abogen(QWidget):
        )
        dialog.setWindowModality(Qt.NonModal)
        dialog.setModal(False)
-        dialog.show()
-
-        # We'll handle the dialog result asynchronously
+        dialog.show()            # We'll handle the dialog result asynchronously
        def on_dialog_finished(result):
            if result != QDialog.Accepted:
                return False
@@ -848,6 +928,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"):
@@ -856,10 +937,54 @@ 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]
+            
+            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'])]
+                            publication_year = re.sub(r'<[^>]+>', '', str(dialog.book_metadata.get('publication_year', 'Unknown')))
+                            
+                            f.write(f"Title: {title}\n")
+                            f.write(f"Authors: {', '.join(authors)}\n")
+                            f.write(f"Publisher: {publisher}\n")
+                            f.write(f"Publication Year: {publication_year}\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
+                prefix=f"{base_name}_", suffix=".txt", dir=temp_dir
            )
            os.close(fd)
            with open(tmp, "w", encoding="utf-8") as f:
@@ -1097,12 +1222,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()

@@ -1200,6 +1333,10 @@ class abogen(QWidget):
            self.conversion_thread.replace_single_newlines = (
                self.replace_single_newlines
            )
+            # Pass separate_chapters_format setting
+            self.conversion_thread.separate_chapters_format = self.separate_chapters_format
+            # Pass subtitle format setting
+            self.conversion_thread.subtitle_format = self.config.get("subtitle_format", "srt")
            # Pass chapter count for EPUB or PDF files
            if self.selected_file_type in ["epub", "pdf"] and hasattr(
                self, "selected_chapters"
@@ -1413,26 +1550,120 @@ class abogen(QWidget):
                "Open File Error", f"Could not open file:\n{e}"
            )

+    def _get_preview_cache_path(self):
+        """Generate the expected cache path for the current voice settings."""
+        speed = self.speed_slider.value() / 100.0
+        voice_to_cache = ""
+        lang_to_cache = ""
+
+        if self.mixed_voice_state:
+            components = [f"{name}*{weight}" for name, weight in self.mixed_voice_state]
+            voice_formula = " + ".join(filter(None, components))
+            voice_to_cache = voice_formula
+            if self.selected_profile_name:
+                from voice_profiles import load_profiles
+                entry = load_profiles().get(self.selected_profile_name, {})
+                lang_to_cache = entry.get("language")
+            else:
+                lang_to_cache = self.selected_lang
+            if not lang_to_cache and self.mixed_voice_state:
+                lang_to_cache = (
+                    self.mixed_voice_state[0][0][0]
+                    if self.mixed_voice_state and self.mixed_voice_state[0][0]
+                    else None
+                )
+        elif self.selected_voice:
+            lang_to_cache = self.selected_voice[0]
+            voice_to_cache = self.selected_voice
+        else:  # No voice or profile selected
+            return None
+
+        if not lang_to_cache or not voice_to_cache:  # Not enough info
+            return None
+
+        cache_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME, "preview_cache")
+        
+        if "*" in voice_to_cache:  # Voice formula
+            voice_id = f"voice_formula_{hashlib.md5(voice_to_cache.encode()).hexdigest()[:8]}"
+        else:  # Single voice
+            voice_id = voice_to_cache
+            
+        filename = f"{voice_id}_{lang_to_cache}_{speed:.2f}.wav"
+        return os.path.join(cache_dir, filename)
+
    def preview_voice(self):
        if self.preview_playing:
            try:
-                import pygame
-
-                pygame.mixer.music.stop()
-            except Exception:
-                pass
+                if self.play_audio_thread and self.play_audio_thread.isRunning():
+                    # Call the stop method on PlayAudioThread to safely handle stopping
+                    self.play_audio_thread.stop()
+                    self.play_audio_thread.wait(500)  # Wait a bit
+            except Exception as e:
+                print(f"Error stopping preview audio: {e}")
            self._preview_cleanup()
            return

        if hasattr(self, "preview_thread") and self.preview_thread.isRunning():
            return

+        # Check for cache first
+        cached_path = self._get_preview_cache_path()
+        if cached_path and os.path.exists(cached_path):
+            print(f"Cache hit for {cached_path}")
+            self.btn_preview.setEnabled(False)  # Disable button briefly
+            self.voice_combo.setEnabled(False)
+            self.btn_voice_formula_mixer.setEnabled(False)
+            self.btn_start.setEnabled(False)
+            
+            # Directly play from cache
+            self.preview_playing = True
+            self.btn_preview.setIcon(self.stop_icon)
+            self.btn_preview.setToolTip("Stop preview")
+            self.btn_preview.setEnabled(True)
+
+            def cleanup_cached_play():
+                self._preview_cleanup()
+
+            try:
+                # Ensure pygame mixer is initialized for the audio thread
+                import pygame
+                if not pygame.mixer.get_init():
+                    pygame.mixer.init()
+
+                self.play_audio_thread = PlayAudioThread(cached_path)
+                self.play_audio_thread.finished.connect(cleanup_cached_play)
+                self.play_audio_thread.error.connect(
+                    lambda msg: (self._show_preview_error_box(msg), cleanup_cached_play())
+                )
+                self.play_audio_thread.start()
+            except Exception as e:
+                self._show_error_message_box(
+                    "Preview Error", f"Could not play cached preview audio:\n{e}"
+                )
+                cleanup_cached_play()
+            return
+
+        # If no cache hit, proceed to load pipeline and generate
        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
+
+        # 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):
@@ -1462,14 +1693,14 @@ class abogen(QWidget):
            # 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 if available, else first voice code
+            # 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 = None
+                lang = self.selected_lang
            if not lang and self.mixed_voice_state:
                lang = (
                    self.mixed_voice_state[0][0][0]
@@ -1480,49 +1711,70 @@ class abogen(QWidget):
            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, self.use_gpu
+            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)
        self.preview_thread.start()

-    def _play_preview_audio(self):
+    def _play_preview_audio(self, from_cache=True):  # from_cache default is now False
+        # If preview_thread is the source, get temp_wav from it
+        if hasattr(self, 'preview_thread') and not from_cache:
            temp_wav = self.preview_thread.temp_wav
-        if not temp_wav:
-            self.loading_movie.stop()
+        elif from_cache:  # This case is now handled before calling _play_preview_audio
+            cached_path = self._get_preview_cache_path()
+            if cached_path and os.path.exists(cached_path):
+                temp_wav = cached_path
+            else:  # Should not happen if cache check was done
+                self._show_error_message_box("Preview Error", "Cache file expected but not found.")
+                self._preview_cleanup()
+                return
+        else:  # Should have temp_wav from preview_thread or handled by cache check
+            self._show_error_message_box("Preview Error", "Preview audio path not found.")
+            self._preview_cleanup()
+            return

+        if not temp_wav:
+            if hasattr(self, 'loading_movie'): self.loading_movie.stop()
            self._show_error_message_box(
                "Preview Error", "Preview error: No audio generated."
            )
-            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)
+            self._preview_cleanup()
            return
+            
        # stop loading animation, switch to stop icon
-        self.loading_movie.stop()
+        if hasattr(self, 'loading_movie'): self.loading_movie.stop()
        self.preview_playing = True
        self.btn_preview.setIcon(self.stop_icon)
        self.btn_preview.setToolTip("Stop preview")
        self.btn_preview.setEnabled(True)

        def cleanup():
+            # Only remove if not from cache AND it's a temp file from VoicePreviewThread
+            if not from_cache and hasattr(self, 'preview_thread') and hasattr(self.preview_thread, 'temp_wav') and self.preview_thread.temp_wav == temp_wav:
                try:
+                    if os.path.exists(temp_wav):  # Ensure it exists before trying to remove
                        os.remove(temp_wav)
                except Exception:
                    pass
            self._preview_cleanup()

        try:
-            self.audio_thread = PlayAudioThread(temp_wav)
-            self.audio_thread.finished.connect(cleanup)
-            self.audio_thread.error.connect(
+            # Ensure pygame mixer is initialized for the audio thread
+            import pygame
+            if not pygame.mixer.get_init():
+                pygame.mixer.init()
+
+            self.play_audio_thread = PlayAudioThread(temp_wav)
+            self.play_audio_thread.finished.connect(cleanup)
+            self.play_audio_thread.error.connect(
                lambda msg: (self._show_preview_error_box(msg), cleanup())
            )
-            self.audio_thread.start()
+            self.play_audio_thread.start()
        except Exception as e:
            self._show_error_message_box(
                "Preview Error", f"Could not play preview audio:\n{e}"
@@ -1545,6 +1797,11 @@ class abogen(QWidget):

    def _preview_cleanup(self):
        self.preview_playing = False
+        if hasattr(self, 'loading_movie'): self.loading_movie.stop()
+        try:
+            if hasattr(self, 'loading_movie'): 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)
@@ -1676,12 +1933,49 @@ class abogen(QWidget):
        max_words_action.triggered.connect(self.set_max_subtitle_words)
        menu.addAction(max_words_action)
        
-        # Add seperator
+        # Add subtitle format option
+        subtitle_format_menu = QMenu("Subtitle format", self)
+        subtitle_format_menu.setToolTip("Choose the format for generated subtitles")
+        
+        subtitle_format_group = QActionGroup(self)
+        subtitle_format_group.setExclusive(True)
+        
+        subtitle_format = self.config.get("subtitle_format", "srt")
+        for format_option in ["srt", "ass (wide)", "ass (narrow)", "ass (centered wide)", "ass (centered narrow)"]:
+            format_action = QAction(f"{format_option}", self)
+            format_action.setCheckable(True)
+            format_action.setChecked(subtitle_format == format_option)
+            format_action.triggered.connect(lambda checked, fmt=format_option: self.set_subtitle_format(fmt))
+            subtitle_format_group.addAction(format_action)
+            subtitle_format_menu.addAction(format_action)
+            
+        menu.addMenu(subtitle_format_menu)
+        
+        # Add separate chapters format option
+        separate_chapters_format_menu = QMenu("Separate chapters audio format", self)
+        separate_chapters_format_menu.setToolTip("Choose the format for individual chapter files")
+        
+        format_group = QActionGroup(self)
+        format_group.setExclusive(True)
+        
+        for format_option in ["wav", "flac", "mp3", "opus"]:
+            format_action = QAction(format_option, self)
+            format_action.setCheckable(True)
+            format_action.setChecked(self.separate_chapters_format == format_option)
+            format_action.triggered.connect(lambda checked, fmt=format_option: self.set_separate_chapters_format(fmt))
+            format_group.addAction(format_action)
+            separate_chapters_format_menu.addAction(format_action)
+            
+        menu.addMenu(separate_chapters_format_menu)
+
+        # Add separator
        menu.addSeparator()

-        # Add shortcut to desktop (Windows only)
-        if platform.system() == "Windows":
-            add_shortcut_action = QAction("Create desktop shortcut", self)
+        # Add shortcut to desktop (Windows or Linux)
+        if platform.system() == "Windows" or platform.system() == "Linux":
+            # 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)

@@ -1696,7 +1990,7 @@ class abogen(QWidget):
        menu.addAction(open_temp_action)

        # Add clear temporary files option
-        clear_temp_action = QAction("Clear all temporary files", self)
+        clear_temp_action = QAction("Clear temporary files", self)
        clear_temp_action.triggered.connect(self.clear_temp_files)
        menu.addAction(clear_temp_action)

@@ -1754,10 +2048,12 @@ class abogen(QWidget):

    def add_shortcut_to_desktop(self):
        """Create a desktop shortcut to this program using PowerShell."""
-        import sys, subprocess
-        from PyQt5.QtWidgets import QMessageBox
+        import sys
+        from platformdirs import user_desktop_dir
+        from utils import create_process

        try:
+            if platform.system() == "Windows":
                # where to put the .lnk
                desktop = user_desktop_dir()
                shortcut_path = os.path.join(desktop, "abogen.lnk")
@@ -1774,29 +2070,73 @@ class abogen(QWidget):
                # 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
+                    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()"
            
-            # 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()
+                # Run PowerShell with the command directly
+                proc = create_process("powershell -NoProfile -ExecutionPolicy Bypass -Command \"" + ps_cmd + "\"")
+                proc.wait()
            
-            subprocess.run(
-                ["powershell", "-NoProfile", "-Command", ps_cmd],
-                check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
+                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,
@@ -1804,12 +2144,37 @@ class abogen(QWidget):
                    f"Shortcut created on desktop:\n{shortcut_path}",
                )

-        except subprocess.CalledProcessError as e:
-            QMessageBox.critical(
+                # Offer installation for current user under ~/.local/share/applications
+                reply = QMessageBox.question(
                    self,
-                "Shortcut Error",
-                f"PowerShell failed:\n{e.stderr.decode(errors='ignore')}",
+                    "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."
+                )
+
        except Exception as e:
            QMessageBox.critical(
                self, "Shortcut Error", f"Could not create shortcut:\n{e}"
@@ -1820,25 +2185,37 @@ class abogen(QWidget):
        save_config(self.config)

    def show_voice_formula_dialog(self):
-        # If a profile is selected in combo, open mixer with that profile
+        from voice_profiles import load_profiles
+
+        profiles = load_profiles()
        initial_state = None
        selected_profile = self.selected_profile_name
        if selected_profile:
-            entry = load_profiles().get(selected_profile, {})
-            # support new dict format
+            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 = [(self.selected_voice, 1.0)] if self.selected_voice 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:
-            # After OK, select the profile in combo and update config
            if dialog.current_profile:
                self.selected_profile_name = dialog.current_profile
                self.config["selected_profile_name"] = dialog.current_profile
@@ -1991,7 +2368,7 @@ class abogen(QWidget):
            pass

    def clear_temp_files(self):
-        """Clear all temporary files created by the program."""
+        """Clear temporary files created by the program."""
        import glob

        try:
@@ -2005,25 +2382,49 @@ class abogen(QWidget):
            # Count the files
            file_count = len(temp_files)

-            if file_count == 0:
+            # Check for preview cache files
+            preview_cache_dir = os.path.join(temp_dir, "preview_cache")
+            preview_files = []
+            if os.path.exists(preview_cache_dir):
+                preview_pattern = os.path.join(preview_cache_dir, "*.wav")
+                preview_files = glob.glob(preview_pattern)
+            
+            preview_count = len(preview_files)
+            
+            if file_count == 0 and preview_count == 0:
                QMessageBox.information(
                    self, "No Temporary Files", "No temporary files were found."
                )
                return

-            # Confirm with the user
-            confirm = QMessageBox.question(
-                self,
-                "Clear Temporary Files",
-                f"Found {file_count} temporary file{'s' if file_count != 1 else ''} in the {PROGRAM_NAME} temp folder.\n"
-                "Do you want to delete them?",
-                QMessageBox.Yes | QMessageBox.No,
-            )
+            # Create a custom message box with checkbox
+            msg_box = QMessageBox(self)
+            msg_box.setIcon(QMessageBox.Question)
+            msg_box.setWindowTitle("Clear Temporary Files")
            
-            if confirm != QMessageBox.Yes:
+            msg_text = f"Found {file_count} temporary file{'s' if file_count != 1 else ''} in the {PROGRAM_NAME} temp folder."
+            if preview_count > 0:
+                msg_text += f"\nAlso found {preview_count} preview cache file{'s' if preview_count != 1 else ''}."
+                
+            msg_box.setText(msg_text + "\nDo you want to delete them?")
+            
+            # Add checkbox for preview cache
+            preview_cache_checkbox = QCheckBox("Clean preview cache", msg_box)
+            preview_cache_checkbox.setChecked(False)
+            # Only enable checkbox if preview files exist
+            preview_cache_checkbox.setEnabled(preview_count > 0)
+            
+            # Add the checkbox to the layout
+            msg_box.setCheckBox(preview_cache_checkbox)
+            
+            # Add buttons
+            msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+            msg_box.setDefaultButton(QMessageBox.Yes)
+            
+            if msg_box.exec_() != QMessageBox.Yes:
                return

-            # Delete the files
+            # Delete the text files
            deleted_count = 0
            for file_path in temp_files:
                try:
@@ -2032,11 +2433,24 @@ class abogen(QWidget):
                except Exception as e:
                    print(f"Error deleting {file_path}: {e}")
            
+            # Delete preview cache files if checkbox is checked
+            deleted_preview_count = 0
+            if preview_cache_checkbox.isChecked() and preview_count > 0:
+                for file_path in preview_files:
+                    try:
+                        os.remove(file_path)
+                        deleted_preview_count += 1
+                    except Exception as e:
+                        print(f"Error deleting preview cache {file_path}: {e}")
+
+            # Build result message
+            result_msg = f"Successfully deleted {deleted_count} temporary file{'s' if deleted_count != 1 else ''}."
+            if preview_cache_checkbox.isChecked() and deleted_preview_count > 0:
+                result_msg += f"\nAlso deleted {deleted_preview_count} preview cache file{'s' if deleted_preview_count != 1 else ''}."
+                
            # Show results
            QMessageBox.information(
-                self,
-                "Temporary Files Cleared",
-                f"Successfully deleted {deleted_count} temporary file{'s' if deleted_count != 1 else ''}.",
+                self, "Temporary Files Cleared", result_msg
            )

            # If currently selected file is in the temp directory, clear the UI
@@ -2080,3 +2494,18 @@ class abogen(QWidget):
                "Setting Saved",
                f"Maximum words per subtitle set to {value}.",
            )
+
+    def set_separate_chapters_format(self, fmt):
+        """Set the format for separate chapters audio files."""
+        self.separate_chapters_format = fmt
+        self.config["separate_chapters_format"] = fmt
+        save_config(self.config)
+
+    def set_subtitle_format(self, fmt):
+        """Set the subtitle format."""
+        self.config["subtitle_format"] = fmt
+        save_config(self.config)
+
+    def show_model_download_warning(self, title, message):
+        QMessageBox.information(self, title, message)
+
@@ -0,0 +1,36 @@
+log_callback = None
+show_warning_signal_emitter = None  # Renamed for clarity
+
+def set_log_callback(cb):
+    global log_callback
+    log_callback = cb
+
+def set_show_warning_signal_emitter(emitter):  # Renamed for clarity
+    global show_warning_signal_emitter
+    show_warning_signal_emitter = emitter
+
+from huggingface_hub import hf_hub_download
+
+def tracked_hf_hub_download(*args, **kwargs):
+    try:
+        local_kwargs = dict(kwargs)
+        local_kwargs["local_files_only"] = True
+        hf_hub_download(*args, **local_kwargs)
+    except Exception:
+        repo_id = kwargs.get("repo_id", "<unknown repo>")
+        filename = kwargs.get("filename", "<unknown file>")
+        if filename.endswith(".pth"):
+            msg = f"\nDownloading model '{filename}' from Hugging Face ({repo_id}). This may take a while. Please wait..."
+            if show_warning_signal_emitter:  # Check if the emitter is set
+                show_warning_signal_emitter.emit("Downloading Model", f"Downloading model '{filename}' from Hugging Face repository '{repo_id}'. This may take a while, please wait.")
+        else:
+            msg = f"\nDownloading '{filename}' from Hugging Face ({repo_id}). Please wait..."
+        if log_callback:
+            print(msg, flush=True)
+            log_callback(msg)
+        else:
+            print(msg, flush=True)
+    return hf_hub_download(*args, **kwargs)
+
+import huggingface_hub
+huggingface_hub.hf_hub_download = tracked_hf_hub_download
@@ -0,0 +1,16 @@
+import gpustat
+
+def check():
+    try:
+        stats = gpustat.new_query()
+    except Exception:
+        return False
+
+    for gpu in stats.gpus:
+        print(gpu.name)
+        if 'nvidia' in gpu.name.lower():
+            return True
+    return False
+
+if __name__ == "__main__":
+    print(check())
@@ -10,6 +10,10 @@ from gui import abogen
 from utils import get_resource_path
 from constants import PROGRAM_NAME, VERSION

+# Set environment variables for AMD ROCm
+os.environ["MIOPEN_FIND_MODE"] = "FAST"
+os.environ["MIOPEN_CONV_PRECISE_ROCM_TUNING"] = "0"
+
 # Ensure sys.stdout and sys.stderr are valid in GUI mode
 if sys.stdout is None:
    sys.stdout = open(os.devnull, "w")
@@ -48,6 +52,13 @@ def main():
    if icon_path:
        app.setWindowIcon(QIcon(icon_path))

+    # Set the .desktop name on Linux
+    if platform.system() == "Linux":
+        try:
+            app.setDesktopFileName("abogen.desktop")
+        except AttributeError:
+            pass
+
    ex = abogen()
    ex.show()
    sys.exit(app.exec_())
@@ -1,4 +1,5 @@
 import os
+import sys
 import json
 import warnings
 import platform
@@ -66,10 +67,20 @@ def get_version():

 # Define config path
 def get_user_config_path():
-    if os.name == "nt":
-        config_dir = os.path.join(os.environ["APPDATA"], "abogen")
+    from platformdirs import user_config_dir
+
+    # 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 = os.path.join(os.path.expanduser("~"), ".config", "abogen")
+            config_dir = user_config_dir("abogen", appauthor=False, roaming=True)
+    else:
+        # 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")

@@ -92,6 +103,89 @@ def clean_text(text, *args, **kwargs):
    return text


+default_encoding = sys.getfilesystemencoding()
+
+def create_process(cmd, stdin=None, text=True, capture_output=False):
+    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 not capturing
+    if proc.stdout and not capture_output:
+        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:
@@ -109,10 +203,16 @@ def save_config(config):


 def calculate_text_length(text):
-    # Remove double newlines (replace them with single newlines)
-    cleaned_text = text.replace("\n\n", "")
+    # Ignore chapter markers
+    text = re.sub(r"<<CHAPTER_MARKER:.*?>>", "", text)
+    # Ignore metadata patterns
+    text = re.sub(r"<<METADATA_[^:]+:[^>]*>>", "", text)
+    # Ignore newlines
+    text = text.replace("\n", "")
+    # Ignore leading/trailing spaces
+    text = text.strip()
    # Calculate character count
-    char_count = len(cleaned_text)
+    char_count = len(text)
    return char_count


@@ -131,35 +231,26 @@ def prevent_sleep_start():
    system = platform.system()
    if system == "Windows":
        import ctypes
-
        ctypes.windll.kernel32.SetThreadExecutionState(
            0x80000000 | 0x00000001 | 0x00000040
-        )  # ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED
-    elif system == "Darwin":
-        _sleep_procs["Darwin"] = subprocess.Popen(["caffeinate"])
-    elif system == "Linux":
-        try:
-            _sleep_procs["Linux"] = subprocess.Popen(
-                [
-                    "systemd-inhibit",
-                    "--what=sleep",
-                    "--why=TextToAudiobook conversion",
-                    "sleep",
-                    "999999",
-                ]
        )
-        except Exception:
-            try:
-                subprocess.Popen(["xdg-screensaver", "reset"])
-            except Exception:
-                pass
+    elif system == "Darwin":
+        _sleep_procs["Darwin"] = create_process(["caffeinate"])
+    elif system == "Linux":
+        # use a sleep that never exits so inhibition stays active
+        _sleep_procs["Linux"] = create_process([
+            "systemd-inhibit",
+            "--what=handle-lid-switch:sleep",
+            "--mode=block",
+            "sleep",
+            "infinity",
+        ])


 def prevent_sleep_end():
    system = platform.system()
    if system == "Windows":
        import ctypes
-
        ctypes.windll.kernel32.SetThreadExecutionState(0x80000000)  # ES_CONTINUOUS
    elif system in ("Darwin", "Linux") and _sleep_procs[system]:
        try:
@@ -47,7 +47,7 @@ VOICE_MIXER_WIDTH = 100
 SLIDER_WIDTH = 32
 MIN_WINDOW_WIDTH = 600
 MIN_WINDOW_HEIGHT = 400
-INITIAL_WINDOW_WIDTH = 1000
+INITIAL_WINDOW_WIDTH = 1200
 INITIAL_WINDOW_HEIGHT = 500

 # Language options for the language selector loaded from constants
@@ -264,14 +264,12 @@ class HoverLabel(QLabel):
        self.voice_name = voice_name
        self.setMouseTracking(True)
        self.setStyleSheet(
-            "background-color: #e0e0e0; border-radius: 4px; padding: 3px 6px 3px 6px; margin: 2px;"
+            "background-color: rgba(140, 140, 140, 0.15); border-radius: 4px; padding: 3px 6px 3px 6px; margin: 2px;"
        )

        # Create delete button
        self.delete_button = QPushButton("×", self)
        self.delete_button.setFixedSize(16, 16)
-        self.delete_button = QPushButton("×", self)
-        self.delete_button.setFixedSize(16, 16)
        self.delete_button.setStyleSheet(
            """
            QPushButton {
@@ -310,6 +308,12 @@ class HoverLabel(QLabel):
 class VoiceFormulaDialog(QDialog):
    def __init__(self, parent=None, initial_state=None, selected_profile=None):
        super().__init__(parent)
+        # Store original profile/mix state for restoration on cancel
+        self._original_profile_name = None
+        self._original_mixed_voice_state = None
+        if parent is not None:
+            self._original_profile_name = getattr(parent, "selected_profile_name", None)
+            self._original_mixed_voice_state = getattr(parent, "mixed_voice_state", None)
        profiles = load_profiles()
        self._virtual_new_profile = False
        if not profiles:
@@ -413,6 +417,11 @@ class VoiceFormulaDialog(QDialog):
            self.language_combo.setCurrentIndex(idx)
        self.language_combo.currentIndexChanged.connect(self.mark_profile_modified)
        header_row.addWidget(self.language_combo)
+        # Preview current voice mix using main window's preview
+        self.btn_preview_mix = QPushButton("Preview", self)
+        self.btn_preview_mix.setToolTip("Preview current voice mix")
+        self.btn_preview_mix.clicked.connect(self.preview_current_mix)
+        header_row.addWidget(self.btn_preview_mix)
        mixer_layout.addLayout(header_row)

        # Error message
@@ -475,7 +484,6 @@ class VoiceFormulaDialog(QDialog):

        self.add_voices(initial_state or [])
        self.update_weighted_sums()
-        self.update_subtitle_combo_enabled()

        # assemble splitter
        splitter.addWidget(profile_widget)
@@ -496,8 +504,6 @@ class VoiceFormulaDialog(QDialog):
        for vm in self.voice_mixers:
            vm.spin_box.valueChanged.connect(self.mark_profile_modified)
            vm.checkbox.stateChanged.connect(lambda *_: self.mark_profile_modified())
-            vm.spin_box.valueChanged.connect(self.update_subtitle_combo_enabled)
-            vm.checkbox.stateChanged.connect(self.update_subtitle_combo_enabled)

    def keyPressEvent(self, event):
        # Bind Delete key to delete_profile when a profile is selected
@@ -682,8 +688,6 @@ class VoiceFormulaDialog(QDialog):
        voice_mixer.checkbox.stateChanged.connect(
            lambda *_: self.mark_profile_modified()
        )
-        voice_mixer.spin_box.valueChanged.connect(self.update_subtitle_combo_enabled)
-        voice_mixer.checkbox.stateChanged.connect(self.update_subtitle_combo_enabled)
        return voice_mixer

    def handle_voice_checkbox(self, voice_mixer, state):
@@ -713,6 +717,9 @@ class VoiceFormulaDialog(QDialog):
        ]

        total = sum(w for _, w in selected)
+        # disable Preview if no voices selected, but don't enable while loading
+        if not getattr(self, "_loading", False):
+            self.btn_preview_mix.setEnabled(total > 0)

        if total > 0:
            self.error_label.hide()
@@ -731,7 +738,7 @@ class VoiceFormulaDialog(QDialog):
                percentage = weight / total * 100
                # Make the voice name bold and include percentage
                voice_label = HoverLabel(
-                    f'<b><span style="color:#1976d2">{name}: {percentage:.1f}%</span></b>',
+                    f'<b><span style="color:#007dff">{name}: {percentage:.1f}%</span></b>',
                    name,
                )
                voice_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
@@ -743,20 +750,6 @@ class VoiceFormulaDialog(QDialog):
            self.error_label.show()
            self.weighted_sums_container.hide()

-    def update_subtitle_combo_enabled(self):
-        # Only enable subtitle_combo if at least one selected voice is from supported languages
-        selected_langs = set()
-        for vm in self.voice_mixers:
-            if vm.checkbox.isChecked() and vm.spin_box.value() > 0:
-                lang_code = vm.voice_name[0]
-                selected_langs.add(lang_code)
-        enable = any(
-            lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
-            for lang in selected_langs
-        )
-        if self.subtitle_combo:
-            self.subtitle_combo.setEnabled(enable)
-
    def disable_voice_by_name(self, voice_name):
        for mixer in self.voice_mixers:
            if mixer.voice_name == voice_name:
@@ -819,7 +812,6 @@ class VoiceFormulaDialog(QDialog):
            # sync enabled state
            vm.toggle_inputs()
        self.update_weighted_sums()
-        self.update_subtitle_combo_enabled()

    def save_profile_by_name(self, name):
        profiles = load_profiles()
@@ -846,10 +838,10 @@ class VoiceFormulaDialog(QDialog):
            self.update_weighted_sums()

    def _handle_zero_weight_profiles(self):
-        if self.profile_list.count() <= 1:
+        profiles = load_profiles()
+        if len(profiles) < 1:
            return False
        zero = []
-        profiles = load_profiles()
        for i in range(self.profile_list.count()):
            item = self.profile_list.item(i)
            name = item.text().lstrip("*")
@@ -868,7 +860,6 @@ class VoiceFormulaDialog(QDialog):
        if not zero:
            return False
        msg = f"{len(zero)} invalid profile(s) with no voices selected or their total weights are 0. They will be ignored and deleted. Do you want to delete?"
-        # Use Delete instead of Ignore
        reply = QMessageBox.question(
            self,
            "Invalid Profiles",
@@ -929,6 +920,13 @@ class VoiceFormulaDialog(QDialog):
        super().accept()

    def reject(self):
+        # Restore parent's profile/mix state on cancel
+        parent = self.parent()
+        if parent is not None:
+            if hasattr(self, "_original_profile_name"):
+                parent.selected_profile_name = self._original_profile_name
+            if hasattr(self, "_original_mixed_voice_state"):
+                parent.mixed_voice_state = self._original_mixed_voice_state
        # Prompt to save if unsaved changes, then check for zero-weight error after save
        if self._has_unsaved_changes():
            if not self._prompt_save_changes():
@@ -938,6 +936,13 @@ class VoiceFormulaDialog(QDialog):
        super().reject()

    def closeEvent(self, event):
+        # Restore parent's profile/mix state on close
+        parent = self.parent()
+        if parent is not None:
+            if hasattr(self, "_original_profile_name"):
+                parent.selected_profile_name = self._original_profile_name
+            if hasattr(self, "_original_mixed_voice_state"):
+                parent.mixed_voice_state = self._original_mixed_voice_state
        # Prompt to save if unsaved changes, then check for zero-weight error after save
        if self._has_unsaved_changes():
            if not self._prompt_save_changes():
@@ -963,8 +968,22 @@ class VoiceFormulaDialog(QDialog):
        self.update_profile_list_colors()

    def new_profile(self):
+        import re
+
+        while True:
            name, ok = QInputDialog.getText(self, "New Profile", "Enter profile name:")
-        if ok and name:
+            if not ok or not name:
+                break
+            name = name.strip()  # Remove leading/trailing spaces
+            if not name:
+                continue
+            if not re.match(r"^[\w\- ]+$", name):
+                QMessageBox.warning(
+                    self,
+                    "Invalid Name",
+                    "Profile name can only contain letters, numbers, spaces, underscores, and hyphens.",
+                )
+                continue
            profiles = load_profiles()
            # Remove 'New profile' placeholder if not persisted in JSON
            if (
@@ -977,7 +996,7 @@ class VoiceFormulaDialog(QDialog):
                self._profile_dirty.pop("New profile", None)
            if name in profiles:
                QMessageBox.warning(self, "Duplicate Name", "Profile already exists.")
-                return
+                continue
            profiles[name] = {
                "voices": [],
                "language": self.language_combo.currentData(),
@@ -996,6 +1015,7 @@ class VoiceFormulaDialog(QDialog):
            parent = self.parent()
            if hasattr(parent, "populate_profiles_in_voice_combo"):
                parent.populate_profiles_in_voice_combo()
+            break
        self.update_profile_save_buttons()
        self.update_profile_list_colors()
        self.update_weighted_sums()
@@ -1182,21 +1202,71 @@ class VoiceFormulaDialog(QDialog):
                )

    def rename_profile(self, item):
+        name = item.text().lstrip("*")
+        # block if profile has unsaved changes and it's not a virtual New profile
+        if self._profile_dirty.get(name, False) and not (
+            self._virtual_new_profile and name == "New profile"
+        ):
+            QMessageBox.warning(
+                self, "Unsaved Changes", "Please save the profile before renaming."
+            )
+            return
        old = item.text().lstrip("*")
+        import re
+
+        while True:
            new, ok = QInputDialog.getText(
                self, "Rename Profile", f"Profile name:", text=old
            )
-        if ok and new and new != old:
+            if not ok or not new or new == old:
+                break
+            new = new.strip()  # Remove leading/trailing spaces
+            if not new:
+                continue
+            if not re.match(r"^[\w\- ]+$", new):
+                QMessageBox.warning(
+                    self,
+                    "Invalid Name",
+                    "Profile name can only contain letters, numbers, spaces, underscores, and hyphens.",
+                )
+                continue
+
            profiles = load_profiles()
            if new in profiles:
                QMessageBox.warning(self, "Duplicate Name", "Profile already exists.")
-                return
+                continue
+
+            # Special case for renaming the virtual "New profile"
+            if self._virtual_new_profile and name == "New profile":
+                # Create the profile with the new name
+                profiles[new] = {
+                    "voices": self.get_selected_voices(),
+                    "language": self.language_combo.currentData(),
+                }
+                save_profiles(profiles)
+
+                # Update tracking properties
+                self._virtual_new_profile = False
+                self._profile_dirty.pop("New profile", None)
+                self._profile_dirty[new] = False
+
+                # Update the current profile name
+                self.current_profile = new
+                item.setText(new)
+            else:
+                # Standard renaming for regular profiles
                profiles[new] = profiles.pop(old)
                save_profiles(profiles)
                item.setText(new)
+
+                # Update the current profile name if it was renamed
+                if self.current_profile == old:
+                    self.current_profile = new
+
            parent = self.parent()
            if hasattr(parent, "populate_profiles_in_voice_combo"):
                parent.populate_profiles_in_voice_combo()
+            break
        self.update_profile_save_buttons()
        self.update_profile_list_colors()

@@ -1227,6 +1297,13 @@ class VoiceFormulaDialog(QDialog):
        self.update_profile_list_colors()

    def duplicate_profile(self, item):
+        name = item.text().lstrip("*")
+        # block duplicating if profile has unsaved changes
+        if self._profile_dirty.get(name, False):
+            QMessageBox.warning(
+                self, "Unsaved Changes", "Please save the profile before duplicating."
+            )
+            return
        src = item.text().lstrip("*")
        profiles = load_profiles()
        base = f"{src}_duplicate"
@@ -1267,10 +1344,16 @@ class VoiceFormulaDialog(QDialog):
            item = self.profile_list.item(i)
            name = item.text().lstrip("*")
            if self._virtual_new_profile and name == "New profile":
-                item.setBackground(QColor("#fff59d"))  # yellow
+                color = QColor("#ffff00")  # yellow
+                color.setAlpha(64)  # Set transparency
+                item.setBackground(color)
            elif item.text().startswith("*"):
-                item.setBackground(QColor("#fff59d"))  # yellow
+                color = QColor("#ffff00")  # yellow
+                color.setAlpha(64)  # Set transparency
+                item.setBackground(color)
            else:
+                item.setBackground(self.profile_list.palette().base().color()) # Use default list item background
+
                weights = profiles.get(name, {}).get("voices", [])
                # Defensive: only sum if weights is a list of (voice, weight) pairs
                total = 0
@@ -1283,7 +1366,45 @@ class VoiceFormulaDialog(QDialog):
                        ):
                            total += entry[1]
                if total == 0:
-                    item.setBackground(QColor("#ffcdd2"))  # light red
-                else:
-                    item.setBackground(QColor("white"))
+                    color = QColor("#ff0000")  # red
+                    color.setAlpha(64)  # Set transparency
+                    item.setBackground(color)
        self.update_profile_save_buttons()
+
+    def preview_current_mix(self):
+        # Disable preview until playback completes
+        self.btn_preview_mix.setEnabled(False)
+        self.btn_preview_mix.setText("Loading...")
+        self._loading = True
+        parent = self.parent()
+        if parent and hasattr(parent, "preview_voice"):
+            # Apply mixed voices and selected language
+            parent.mixed_voice_state = self.get_selected_voices()
+            parent.selected_profile_name = None
+            lang = self.language_combo.currentData()
+            parent.selected_lang = lang
+            parent.subtitle_combo.setEnabled(
+                lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
+            )
+            # Reset start flag and trigger preview
+            self._started = False
+            parent.preview_voice()
+            # Poll preview_playing: wait for start then end
+            self._preview_poll_timer = QTimer(self)
+            self._preview_poll_timer.timeout.connect(self._check_preview_done)
+            self._preview_poll_timer.start(200)
+
+    def _check_preview_done(self):
+        parent = self.parent()
+        if parent and hasattr(parent, "preview_playing"):
+            # Mark when playback starts
+            if parent.preview_playing:
+                self._started = True
+                # Update button text to "Playing..." when playback starts
+                self.btn_preview_mix.setText("Playing...")
+            # Once started and then stopped, re-enable
+            elif getattr(self, "_started", False):
+                self.btn_preview_mix.setEnabled(True)
+                self.btn_preview_mix.setText("Preview")
+                self._loading = False
+                self._preview_poll_timer.stop()
@@ -1,6 +1,6 @@
 import os
 import json
-from utils import get_user_config_path, get_resource_path
+from utils import get_user_config_path


 def _get_profiles_path():
@@ -7,9 +7,10 @@ https://github.com/user-attachments/assets/9e4fc237-a3cd-46bd-b82c-c608336d6411
 ### What You Need

 - A background image (bg.jpg)
- The subtitle file (.srt) **(created by Abogen)**
+- The subtitle file (.ass) **(created by Abogen)**
+    - Select `ass(centered narrow)` as subtitle format in settings.
 - The audio recording (.wav) **(created by Abogen)**
- [Python](https://www.python.org/downloads/) and FFmpeg installed on your computer:
+- FFmpeg installed on your computer:

 ```bash
 # Windows
@@ -22,22 +23,12 @@ brew install ffmpeg
 sudo apt install ffmpeg
 ```

-### Step 1: Process the Subtitle File
-
-Run this command to process Abogen's subtitle file:
-
-```
-python convert.py your_subtitle.srt
-```
-
-This creates a properly formatted subtitle file called "your_subtitle_demo.ass" with centered text and appropriate styling.
-
-### Step 2: Create the Video (.webm)
+### Create the Video (.webm)

 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
+ffmpeg -loop 1 -framerate 24 -i bg.jpg -i audio.wav -vf "ass=subtitle.ass" -c:v libvpx-vp9 -b:v 0 -crf 30 -c:a libopus -shortest demo.webm
 ```

 ## For Higher Quality (But Larger) Video (.mp4)
@@ -45,7 +36,7 @@ ffmpeg -loop 1 -framerate 24 -i bg.jpg -i audio.wav -vf "ass=your_subtitle_demo.
 If you need better quality for distribution, use this command instead:

 ```
-ffmpeg -loop 1 -framerate 24 -i bg.jpg -i audio.wav -vf "ass=your_subtitle_demo.ass" -c:v libx264 -preset slow -crf 18 -movflags +faststart -c:a copy -shortest demo.mp4
+ffmpeg -loop 1 -framerate 24 -i bg.jpg -i audio.wav -vf "ass=subtitle.ass" -c:v libx264 -preset slow -crf 18 -movflags +faststart -c:a copy -shortest demo.mp4
 ```

 This creates an MP4 file that's compatible with more devices but larger in size.
@@ -1,220 +0,0 @@
-# FFmpeg commands for creating videos:
-#
-# For WebM (smaller filesize):
-# 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
-#
-# For MP4 (higher quality):
-# ffmpeg -loop 1 -framerate 24 -i bg.jpg -i audio.wav -vf "ass=your_subtitle_demo.ass" -c:v libx264 -preset slow -crf 18 -movflags +faststart -c:a copy -shortest demo.mp4
-#
-# Note: Replace 'audio.wav' with your audio file and 'your_subtitle_demo.ass' with your processed subtitle file
-
-
-import re
-import sys
-from datetime import timedelta
-
-
-def parse_time(s):
-    # For ASS format
-    if ":" in s and "." in s:
-        h, m, s = s.split(":")
-        sec, cs = s.split(".")
-        return timedelta(
-            hours=int(h), minutes=int(m), seconds=int(sec), milliseconds=int(cs) * 10
-        )
-    # For SRT format (00:00:00,000)
-    elif ":" in s and "," in s:
-        parts = s.split(":")
-        h = int(parts[0])
-        m = int(parts[1])
-        sec_parts = parts[2].split(",")
-        sec = int(sec_parts[0])
-        ms = int(sec_parts[1])
-        return timedelta(hours=h, minutes=m, seconds=sec, milliseconds=ms)
-    return None
-
-
-def format_time(t):
-    total_seconds = int(t.total_seconds())
-    cs = int((t.total_seconds() - total_seconds) * 100)
-    h = total_seconds // 3600
-    m = (total_seconds % 3600) // 60
-    s = total_seconds % 60
-    return f"{h}:{m:02}:{s:02}.{cs:02}"
-
-
-# Desired script info and style
-DESIRED_SCRIPT_INFO = """[Script Info]
-Title: Centered Subs
-ScriptType: v4.00+
-PlayResX: 1280
-PlayResY: 720
-"""
-
-DESIRED_STYLE = """[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,60,&H00FFFFFF,&H000000FF,&H00000000,&H64000000,-1,0,0,0,100,100,0,0,1,2,0,5,10,10,10,1
-"""
-
-
-def process_subtitle_file(input_file):
-    output_file = input_file.replace(".ass", "_demo.ass").replace(".srt", "_demo.ass")
-    if output_file == input_file:
-        output_file = f"{input_file}_demo.ass"
-
-    try:
-        with open(input_file, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-    except FileNotFoundError:
-        print(f"❌ Error: Input file '{input_file}' not found")
-        sys.exit(1)
-    except Exception as e:
-        print(f"❌ Error reading file: {e}")
-        sys.exit(1)
-
-    # Check if it's an SRT file
-    is_srt = input_file.lower().endswith(".srt")
-
-    if is_srt:
-        return convert_srt_to_ass(input_file, output_file, lines)
-
-    # Process ASS file
-    header = []
-    events = []
-    in_events = False
-    script_info_found = False
-    styles_found = False
-
-    for line in lines:
-        if line.strip().startswith("[Script Info]"):
-            script_info_found = True
-            header.append(DESIRED_SCRIPT_INFO)
-            continue
-        elif line.strip().startswith("[V4+ Styles]"):
-            styles_found = True
-            header.append(DESIRED_STYLE)
-            continue
-        elif line.strip().startswith("[Events]"):
-            in_events = True
-            header.append(line)
-        elif not in_events:
-            if not script_info_found and not styles_found:
-                header.append(line)
-        else:
-            if line.startswith("Dialogue:"):
-                events.append(line)
-            else:
-                header.append(line)
-
-    parsed_events = []
-    for line in events:
-        match = re.match(r"Dialogue: \d,([^,]+),([^,]+),", line)
-        if not match:
-            parsed_events.append((None, None, line))
-            continue
-        start = parse_time(match.group(1))
-        end = parse_time(match.group(2))
-        parsed_events.append((start, end, line))
-
-    # Cut overlaps
-    fixed_lines = []
-    for i in range(len(parsed_events)):
-        start, end, line = parsed_events[i]
-        if start is None:
-            fixed_lines.append(line)
-            continue
-
-        # Check for next subtitle
-        if i + 1 < len(parsed_events):
-            next_start, _, _ = parsed_events[i + 1]
-            if end > next_start:
-                end = next_start  # cut current subtitle to stop at next one's start
-
-        fixed_line = re.sub(
-            r"Dialogue: \d,[^,]+,[^,]+,",
-            f"Dialogue: 0,{format_time(start)},{format_time(end)},",
-            line,
-            count=1,
-        )
-        fixed_lines.append(fixed_line)
-
-    try:
-        with open(output_file, "w", encoding="utf-8") as f:
-            f.writelines(header)
-            f.writelines(fixed_lines)
-        print(f"✅ Successfully processed. Output file: {output_file}")
-    except Exception as e:
-        print(f"❌ Error writing output file: {e}")
-        sys.exit(1)
-
-
-def convert_srt_to_ass(input_file, output_file, lines):
-    """Convert SRT format to ASS format."""
-    events = []
-    subtitle_blocks = []
-    current_block = []
-
-    # Parse SRT file
-    for line in lines:
-        line = line.strip()
-        if not line:
-            if current_block:
-                subtitle_blocks.append(current_block)
-                current_block = []
-        else:
-            current_block.append(line)
-
-    # Don't forget the last block
-    if current_block:
-        subtitle_blocks.append(current_block)
-
-    # Process subtitle blocks
-    for block in subtitle_blocks:
-        if len(block) < 3:
-            continue  # Invalid block
-
-        # Skip the subtitle number
-        timing_line = block[1]
-
-        # Parse timing information
-        timing_match = re.match(
-            r"(\d+:\d+:\d+,\d+)\s+-->\s+(\d+:\d+:\d+,\d+)", timing_line
-        )
-        if not timing_match:
-            continue
-
-        start_time = parse_time(timing_match.group(1))
-        end_time = parse_time(timing_match.group(2))
-
-        # Combine text lines
-        text = "\\N".join(block[2:])
-
-        # Create ASS Dialogue line
-        dialogue_line = f"Dialogue: 0,{format_time(start_time)},{format_time(end_time)},Default,,0,0,0,,{text}\n"
-        events.append(dialogue_line)
-
-    # Create ASS file
-    try:
-        with open(output_file, "w", encoding="utf-8") as f:
-            f.write(DESIRED_SCRIPT_INFO)
-            f.write(DESIRED_STYLE)
-            f.write("[Events]\n")
-            f.write(
-                "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n"
-            )
-            f.writelines(events)
-        print(f"✅ Successfully converted SRT to ASS. Output file: {output_file}")
-        return True
-    except Exception as e:
-        print(f"❌ Error writing output file: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("❌ Error: No input file specified")
-        print(f"Usage: {sys.argv[0]} <input_file.ass|input_file.srt>")
-        sys.exit(1)
-
-    input_file = sys.argv[1]
-    process_subtitle_file(input_file)
@@ -0,0 +1,130 @@
+[Script Info]
+Title: Generated by Abogen
+ScriptType: v4.00+
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+Dialogue: 0,0:00:00.27,0:00:00.83,Default,,100,100,0,,{\an5}Abogen
+Dialogue: 0,0:00:00.83,0:00:00.96,Default,,100,100,0,,{\an5}is
+Dialogue: 0,0:00:00.96,0:00:01.11,Default,,100,100,0,,{\an5}your
+Dialogue: 0,0:00:01.11,0:00:01.66,Default,,100,100,0,,{\an5}all-in-one
+Dialogue: 0,0:00:01.66,0:00:02.04,Default,,100,100,0,,{\an5}tool
+Dialogue: 0,0:00:02.04,0:00:02.17,Default,,100,100,0,,{\an5}for
+Dialogue: 0,0:00:02.17,0:00:02.53,Default,,100,100,0,,{\an5}turning
+Dialogue: 0,0:00:02.53,0:00:03.22,Default,,100,100,0,,{\an5}text
+Dialogue: 0,0:00:03.22,0:00:03.45,Default,,100,100,0,,{\an5}into
+Dialogue: 0,0:00:03.45,0:00:03.75,Default,,100,100,0,,{\an5}something
+Dialogue: 0,0:00:03.75,0:00:03.85,Default,,100,100,0,,{\an5}you
+Dialogue: 0,0:00:03.85,0:00:04.04,Default,,100,100,0,,{\an5}can
+Dialogue: 0,0:00:04.04,0:00:04.32,Default,,100,100,0,,{\an5}see
+Dialogue: 0,0:00:04.32,0:00:04.45,Default,,100,100,0,,{\an5}and
+Dialogue: 0,0:00:04.45,0:00:05.61,Default,,100,100,0,,{\an5}hear.
+Dialogue: 0,0:00:05.61,0:00:06.02,Default,,100,100,0,,{\an5}Easily
+Dialogue: 0,0:00:06.02,0:00:06.48,Default,,100,100,0,,{\an5}convert
+Dialogue: 0,0:00:06.48,0:00:07.31,Default,,100,100,0,,{\an5}ePub,
+Dialogue: 0,0:00:07.31,0:00:08.40,Default,,100,100,0,,{\an5}PDF,
+Dialogue: 0,0:00:08.40,0:00:08.55,Default,,100,100,0,,{\an5}or
+Dialogue: 0,0:00:08.55,0:00:08.90,Default,,100,100,0,,{\an5}text
+Dialogue: 0,0:00:08.90,0:00:09.21,Default,,100,100,0,,{\an5}file
+Dialogue: 0,0:00:09.21,0:00:09.46,Default,,100,100,0,,{\an5}into
+Dialogue: 0,0:00:09.46,0:00:10.34,Default,,100,100,0,,{\an5}audio
+Dialogue: 0,0:00:10.34,0:00:10.56,Default,,100,100,0,,{\an5}with
+Dialogue: 0,0:00:10.56,0:00:11.17,Default,,100,100,0,,{\an5}subtitles
+Dialogue: 0,0:00:11.17,0:00:11.32,Default,,100,100,0,,{\an5}that
+Dialogue: 0,0:00:11.32,0:00:11.51,Default,,100,100,0,,{\an5}light
+Dialogue: 0,0:00:11.51,0:00:11.71,Default,,100,100,0,,{\an5}up
+Dialogue: 0,0:00:11.71,0:00:12.05,Default,,100,100,0,,{\an5}every
+Dialogue: 0,0:00:12.05,0:00:12.40,Default,,100,100,0,,{\an5}word
+Dialogue: 0,0:00:12.40,0:00:12.51,Default,,100,100,0,,{\an5}as
+Dialogue: 0,0:00:12.51,0:00:12.65,Default,,100,100,0,,{\an5}it’s
+Dialogue: 0,0:00:12.65,0:00:14.21,Default,,100,100,0,,{\an5}spoken.
+Dialogue: 0,0:00:14.21,0:00:14.32,Default,,100,100,0,,{\an5}The
+Dialogue: 0,0:00:14.32,0:00:14.62,Default,,100,100,0,,{\an5}voice
+Dialogue: 0,0:00:14.62,0:00:14.77,Default,,100,100,0,,{\an5}you
+Dialogue: 0,0:00:14.77,0:00:15.65,Default,,100,100,0,,{\an5}hear,
+Dialogue: 0,0:00:15.65,0:00:15.76,Default,,100,100,0,,{\an5}and
+Dialogue: 0,0:00:15.76,0:00:15.86,Default,,100,100,0,,{\an5}the
+Dialogue: 0,0:00:15.86,0:00:16.44,Default,,100,100,0,,{\an5}subtitles
+Dialogue: 0,0:00:16.44,0:00:16.58,Default,,100,100,0,,{\an5}you
+Dialogue: 0,0:00:16.58,0:00:17.03,Default,,100,100,0,,{\an5}see
+Dialogue: 0,0:00:17.03,0:00:17.14,Default,,100,100,0,,{\an5}are
+Dialogue: 0,0:00:17.14,0:00:17.44,Default,,100,100,0,,{\an5}both
+Dialogue: 0,0:00:17.44,0:00:17.91,Default,,100,100,0,,{\an5}created
+Dialogue: 0,0:00:17.91,0:00:18.96,Default,,100,100,0,,{\an5}automatically
+Dialogue: 0,0:00:18.96,0:00:19.14,Default,,100,100,0,,{\an5}by
+Dialogue: 0,0:00:19.14,0:00:19.64,Default,,100,100,0,,{\an5}Abogen
+Dialogue: 0,0:00:19.64,0:00:20.00,Default,,100,100,0,,{\an5}using
+Dialogue: 0,0:00:20.00,0:00:21.14,Default,,100,100,0,,{\an5}Kokoro,
+Dialogue: 0,0:00:21.14,0:00:21.28,Default,,100,100,0,,{\an5}an
+Dialogue: 0,0:00:21.28,0:00:21.88,Default,,100,100,0,,{\an5}open-weight
+Dialogue: 0,0:00:21.88,0:00:22.52,Default,,100,100,0,,{\an5}TTS
+Dialogue: 0,0:00:22.52,0:00:23.18,Default,,100,100,0,,{\an5}model
+Dialogue: 0,0:00:23.18,0:00:23.38,Default,,100,100,0,,{\an5}with
+Dialogue: 0,0:00:23.38,0:00:24.01,Default,,100,100,0,,{\an5}82
+Dialogue: 0,0:00:24.01,0:00:24.37,Default,,100,100,0,,{\an5}million
+Dialogue: 0,0:00:24.37,0:00:25.98,Default,,100,100,0,,{\an5}parameters.
+Dialogue: 0,0:00:25.98,0:00:26.47,Default,,100,100,0,,{\an5}Everything
+Dialogue: 0,0:00:26.47,0:00:26.77,Default,,100,100,0,,{\an5}works
+Dialogue: 0,0:00:26.77,0:00:27.01,Default,,100,100,0,,{\an5}right
+Dialogue: 0,0:00:27.01,0:00:27.11,Default,,100,100,0,,{\an5}on
+Dialogue: 0,0:00:27.11,0:00:27.22,Default,,100,100,0,,{\an5}your
+Dialogue: 0,0:00:27.22,0:00:28.23,Default,,100,100,0,,{\an5}computer,
+Dialogue: 0,0:00:28.23,0:00:28.37,Default,,100,100,0,,{\an5}so
+Dialogue: 0,0:00:28.37,0:00:28.53,Default,,100,100,0,,{\an5}your
+Dialogue: 0,0:00:28.53,0:00:28.94,Default,,100,100,0,,{\an5}files
+Dialogue: 0,0:00:28.94,0:00:29.23,Default,,100,100,0,,{\an5}stay
+Dialogue: 0,0:00:29.23,0:00:29.88,Default,,100,100,0,,{\an5}private
+Dialogue: 0,0:00:29.88,0:00:30.05,Default,,100,100,0,,{\an5}and
+Dialogue: 0,0:00:30.05,0:00:31.16,Default,,100,100,0,,{\an5}secure.
+Dialogue: 0,0:00:31.50,0:00:31.63,Default,,100,100,0,,{\an5}The
+Dialogue: 0,0:00:31.63,0:00:31.97,Default,,100,100,0,,{\an5}easy
+Dialogue: 0,0:00:31.97,0:00:32.54,Default,,100,100,0,,{\an5}interface
+Dialogue: 0,0:00:32.54,0:00:32.81,Default,,100,100,0,,{\an5}lets
+Dialogue: 0,0:00:32.81,0:00:33.23,Default,,100,100,0,,{\an5}anyone
+Dialogue: 0,0:00:33.23,0:00:33.66,Default,,100,100,0,,{\an5}create
+Dialogue: 0,0:00:33.66,0:00:34.88,Default,,100,100,0,,{\an5}audiobooks,
+Dialogue: 0,0:00:34.88,0:00:35.54,Default,,100,100,0,,{\an5}voiceovers
+Dialogue: 0,0:00:35.54,0:00:35.70,Default,,100,100,0,,{\an5}for
+Dialogue: 0,0:00:35.70,0:00:36.68,Default,,100,100,0,,{\an5}Instagram,
+Dialogue: 0,0:00:36.68,0:00:37.23,Default,,100,100,0,,{\an5}YouTube
+Dialogue: 0,0:00:37.23,0:00:37.41,Default,,100,100,0,,{\an5}or
+Dialogue: 0,0:00:37.41,0:00:38.52,Default,,100,100,0,,{\an5}TikTok,
+Dialogue: 0,0:00:38.52,0:00:38.64,Default,,100,100,0,,{\an5}or
+Dialogue: 0,0:00:38.64,0:00:38.89,Default,,100,100,0,,{\an5}just
+Dialogue: 0,0:00:38.89,0:00:39.57,Default,,100,100,0,,{\an5}high-quality
+Dialogue: 0,0:00:39.57,0:00:40.39,Default,,100,100,0,,{\an5}text-to-speech
+Dialogue: 0,0:00:40.39,0:00:40.56,Default,,100,100,0,,{\an5}in
+Dialogue: 0,0:00:40.56,0:00:42.03,Default,,100,100,0,,{\an5}seconds.
+Dialogue: 0,0:00:42.03,0:00:42.32,Default,,100,100,0,,{\an5}Whether
+Dialogue: 0,0:00:42.32,0:00:42.47,Default,,100,100,0,,{\an5}you
+Dialogue: 0,0:00:42.47,0:00:42.67,Default,,100,100,0,,{\an5}want
+Dialogue: 0,0:00:42.67,0:00:42.77,Default,,100,100,0,,{\an5}to
+Dialogue: 0,0:00:42.77,0:00:43.43,Default,,100,100,0,,{\an5}listen,
+Dialogue: 0,0:00:43.43,0:00:43.77,Default,,100,100,0,,{\an5}create
+Dialogue: 0,0:00:43.77,0:00:44.70,Default,,100,100,0,,{\an5}content,
+Dialogue: 0,0:00:44.70,0:00:44.85,Default,,100,100,0,,{\an5}or
+Dialogue: 0,0:00:44.85,0:00:45.07,Default,,100,100,0,,{\an5}bring
+Dialogue: 0,0:00:45.07,0:00:45.22,Default,,100,100,0,,{\an5}your
+Dialogue: 0,0:00:45.22,0:00:45.54,Default,,100,100,0,,{\an5}words
+Dialogue: 0,0:00:45.54,0:00:45.67,Default,,100,100,0,,{\an5}to
+Dialogue: 0,0:00:45.67,0:00:46.58,Default,,100,100,0,,{\an5}life,
+Dialogue: 0,0:00:46.58,0:00:47.10,Default,,100,100,0,,{\an5}Abogen
+Dialogue: 0,0:00:47.10,0:00:47.37,Default,,100,100,0,,{\an5}makes
+Dialogue: 0,0:00:47.37,0:00:47.53,Default,,100,100,0,,{\an5}it
+Dialogue: 0,0:00:47.53,0:00:48.31,Default,,100,100,0,,{\an5}fast,
+Dialogue: 0,0:00:48.31,0:00:48.89,Default,,100,100,0,,{\an5}fun,
+Dialogue: 0,0:00:48.89,0:00:49.02,Default,,100,100,0,,{\an5}and
+Dialogue: 0,0:00:49.02,0:00:50.62,Default,,100,100,0,,{\an5}effortless.
+Dialogue: 0,0:00:50.62,0:00:51.35,Default,,100,100,0,,{\an5}Experience
+Dialogue: 0,0:00:51.35,0:00:51.47,Default,,100,100,0,,{\an5}your
+Dialogue: 0,0:00:51.47,0:00:52.23,Default,,100,100,0,,{\an5}stories,
+Dialogue: 0,0:00:52.23,0:00:52.97,Default,,100,100,0,,{\an5}scripts,
+Dialogue: 0,0:00:52.97,0:00:53.11,Default,,100,100,0,,{\an5}and
+Dialogue: 0,0:00:53.11,0:00:53.64,Default,,100,100,0,,{\an5}ideas
+Dialogue: 0,0:00:53.64,0:00:53.73,Default,,100,100,0,,{\an5}in
+Dialogue: 0,0:00:53.73,0:00:53.83,Default,,100,100,0,,{\an5}a
+Dialogue: 0,0:00:53.83,0:00:54.14,Default,,100,100,0,,{\an5}whole
+Dialogue: 0,0:00:54.14,0:00:54.35,Default,,100,100,0,,{\an5}new
+Dialogue: 0,0:00:54.35,0:00:54.64,Default,,100,100,0,,{\an5}way
+Dialogue: 0,0:00:54.64,0:00:54.79,Default,,100,100,0,,{\an5}with
+Dialogue: 0,0:00:54.79,0:00:55.85,Default,,100,100,0,,{\an5}Abogen.
@@ -1,480 +0,0 @@
-1
-00:00:00,350 --> 00:00:00,962
-Abogen
-
-2
-00:00:00,962 --> 00:00:01,100
-is
-
-3
-00:00:01,100 --> 00:00:01,300
-your
-
-4
-00:00:01,300 --> 00:00:01,887
-all-in-one
-
-5
-00:00:01,887 --> 00:00:02,250
-tool
-
-6
-00:00:02,250 --> 00:00:02,375
-for
-
-7
-00:00:02,375 --> 00:00:02,762
-turning
-
-8
-00:00:02,762 --> 00:00:03,162
-text
-
-9
-00:00:03,162 --> 00:00:03,375
-into
-
-10
-00:00:03,375 --> 00:00:03,725
-something
-
-11
-00:00:03,725 --> 00:00:03,825
-you
-
-12
-00:00:03,825 --> 00:00:04,025
-can
-
-13
-00:00:04,025 --> 00:00:04,312
-see
-
-14
-00:00:04,312 --> 00:00:04,450
-and
-
-15
-00:00:04,450 --> 00:00:05,450
-hear.
-
-16
-00:00:05,450 --> 00:00:05,900
-Easily
-
-17
-00:00:05,900 --> 00:00:06,337
-convert
-
-18
-00:00:06,337 --> 00:00:07,187
-ePub,
-
-19
-00:00:07,187 --> 00:00:08,250
-PDF,
-
-20
-00:00:08,250 --> 00:00:08,412
-or
-
-21
-00:00:08,412 --> 00:00:08,800
-text
-
-22
-00:00:08,800 --> 00:00:09,162
-file
-
-23
-00:00:09,162 --> 00:00:09,425
-into
-
-24
-00:00:09,425 --> 00:00:10,037
-audio
-
-25
-00:00:10,037 --> 00:00:10,237
-with
-
-26
-00:00:10,237 --> 00:00:10,875
-subtitles
-
-27
-00:00:10,875 --> 00:00:11,087
-that
-
-28
-00:00:11,087 --> 00:00:11,287
-light
-
-29
-00:00:11,287 --> 00:00:11,487
-up
-
-30
-00:00:11,487 --> 00:00:11,824
-every
-
-31
-00:00:11,824 --> 00:00:12,175
-word
-
-32
-00:00:12,175 --> 00:00:12,300
-as
-
-33
-00:00:12,300 --> 00:00:12,449
-it’s
-
-34
-00:00:12,449 --> 00:00:13,787
-spoken.
-
-35
-00:00:13,787 --> 00:00:13,925
-The
-
-36
-00:00:13,925 --> 00:00:14,275
-voice
-
-37
-00:00:14,275 --> 00:00:14,425
-you
-
-38
-00:00:14,425 --> 00:00:15,212
-hear,
-
-39
-00:00:15,212 --> 00:00:15,337
-and
-
-40
-00:00:15,337 --> 00:00:15,437
-the
-
-41
-00:00:15,437 --> 00:00:16,024
-subtitles
-
-42
-00:00:16,024 --> 00:00:16,162
-you
-
-43
-00:00:16,162 --> 00:00:16,487
-see
-
-44
-00:00:16,487 --> 00:00:16,649
-are
-
-45
-00:00:16,649 --> 00:00:16,975
-both
-
-46
-00:00:16,975 --> 00:00:17,449
-created
-
-47
-00:00:17,449 --> 00:00:18,362
-automatically
-
-48
-00:00:18,362 --> 00:00:18,550
-by
-
-49
-00:00:18,550 --> 00:00:19,074
-Abogen
-
-50
-00:00:19,074 --> 00:00:19,425
-using
-
-51
-00:00:19,425 --> 00:00:20,512
-Kokoro,
-
-52
-00:00:20,512 --> 00:00:20,637
-a
-
-53
-00:00:20,637 --> 00:00:21,237
-powerful
-
-54
-00:00:21,237 --> 00:00:22,050
-text-to-speech
-
-55
-00:00:22,050 --> 00:00:23,225
-engine.
-
-56
-00:00:23,225 --> 00:00:23,750
-Everything
-
-57
-00:00:23,750 --> 00:00:24,062
-works
-
-58
-00:00:24,062 --> 00:00:24,312
-right
-
-59
-00:00:24,312 --> 00:00:24,412
-on
-
-60
-00:00:24,412 --> 00:00:24,524
-your
-
-61
-00:00:24,524 --> 00:00:25,437
-computer,
-
-62
-00:00:25,437 --> 00:00:25,625
-so
-
-63
-00:00:25,625 --> 00:00:25,812
-your
-
-64
-00:00:25,812 --> 00:00:26,225
-files
-
-65
-00:00:26,225 --> 00:00:26,524
-stay
-
-66
-00:00:26,524 --> 00:00:27,112
-private
-
-67
-00:00:27,112 --> 00:00:27,274
-and
-
-68
-00:00:27,274 --> 00:00:28,337
-secure.
-
-69
-00:00:28,725 --> 00:00:28,862
-The
-
-70
-00:00:28,862 --> 00:00:29,225
-easy
-
-71
-00:00:29,225 --> 00:00:29,824
-interface
-
-72
-00:00:29,824 --> 00:00:30,112
-lets
-
-73
-00:00:30,112 --> 00:00:30,637
-anyone
-
-74
-00:00:30,637 --> 00:00:31,062
-create
-
-75
-00:00:31,062 --> 00:00:32,299
-audiobooks,
-
-76
-00:00:32,299 --> 00:00:33,075
-voiceovers
-
-77
-00:00:33,075 --> 00:00:33,237
-for
-
-78
-00:00:33,237 --> 00:00:34,325
-Instagram,
-
-79
-00:00:34,325 --> 00:00:34,962
-YouTube
-
-80
-00:00:34,962 --> 00:00:35,137
-or
-
-81
-00:00:35,137 --> 00:00:35,950
-TikTok,
-
-82
-00:00:35,950 --> 00:00:36,100
-or
-
-83
-00:00:36,100 --> 00:00:36,325
-just
-
-84
-00:00:36,325 --> 00:00:37,024
-high-quality
-
-85
-00:00:37,024 --> 00:00:37,850
-text-to-speech
-
-86
-00:00:37,850 --> 00:00:38,000
-in
-
-87
-00:00:38,000 --> 00:00:39,187
-seconds.
-
-88
-00:00:39,187 --> 00:00:39,475
-Whether
-
-89
-00:00:39,475 --> 00:00:39,625
-you
-
-90
-00:00:39,625 --> 00:00:39,825
-want
-
-91
-00:00:39,825 --> 00:00:39,924
-to
-
-92
-00:00:39,924 --> 00:00:40,662
-listen,
-
-93
-00:00:40,662 --> 00:00:41,000
-create
-
-94
-00:00:41,000 --> 00:00:41,774
-content,
-
-95
-00:00:41,774 --> 00:00:41,924
-or
-
-96
-00:00:41,924 --> 00:00:42,137
-bring
-
-97
-00:00:42,137 --> 00:00:42,250
-your
-
-98
-00:00:42,250 --> 00:00:42,575
-words
-
-99
-00:00:42,575 --> 00:00:42,700
-to
-
-100
-00:00:42,700 --> 00:00:43,512
-life,
-
-101
-00:00:43,512 --> 00:00:44,075
-Abogen
-
-102
-00:00:44,075 --> 00:00:44,350
-makes
-
-103
-00:00:44,350 --> 00:00:44,525
-it
-
-104
-00:00:44,525 --> 00:00:45,299
-fast,
-
-105
-00:00:45,299 --> 00:00:45,825
-fun,
-
-106
-00:00:45,825 --> 00:00:45,950
-and
-
-107
-00:00:45,950 --> 00:00:47,275
-effortless.
-
-108
-00:00:47,275 --> 00:00:47,962
-Experience
-
-109
-00:00:47,962 --> 00:00:48,075
-your
-
-110
-00:00:48,075 --> 00:00:48,812
-stories,
-
-111
-00:00:48,812 --> 00:00:49,350
-scripts,
-
-112
-00:00:49,350 --> 00:00:49,500
-and
-
-113
-00:00:49,500 --> 00:00:50,075
-ideas
-
-114
-00:00:50,075 --> 00:00:50,174
-in
-
-115
-00:00:50,174 --> 00:00:50,299
-a
-
-116
-00:00:50,299 --> 00:00:50,662
-whole
-
-117
-00:00:50,662 --> 00:00:50,850
-new
-
-118
-00:00:50,850 --> 00:00:51,150
-way
-
-119
-00:00:51,150 --> 00:00:51,299
-with
-
-120
-00:00:51,299 --> 00:00:52,424
-Abogen.
-
@@ -22,7 +22,8 @@ dependencies = [
    "soundfile>=0.13.1",
    "pygame>=2.6.1",
    "charset_normalizer>=3.4.1",
-    "chardet>=5.2.0"
+    "chardet>=5.2.0",
+    "static_ffmpeg>=2.13"
 ]

 classifiers = [
Author	SHA1	Message	Date
Deniz Şafak	d736242016	Update changelog	2025-05-28 13:40:39 +03:00
Deniz Şafak	dfb9256abe	v1.0.9	2025-05-28 13:39:25 +03:00
Deniz Şafak	2f5780f40e	Added new option: `Subtitle format`	2025-05-28 13:28:59 +03:00
Deniz Şafak	010274e703	Improved chapter filename generation	2025-05-28 01:12:38 +03:00
Deniz Şafak	ee2999f2cd	Added chunking/segmenting system	2025-05-28 00:39:08 +03:00
Deniz Şafak	26d4481ee1	"Composer" and "Genre" metadata fields for M4B files are now editable from the text editor, update Readme	2025-05-27 12:49:53 +03:00
Deniz Şafak	c5174d2c0a	Changed audio processing pipeline back to converting temporary WAV files instead of directly creating OPUS and M4B files	2025-05-27 11:13:04 +03:00
Deniz Şafak	bbabc9feed	Update README	2025-05-23 06:46:39 +03:00
Deniz Şafak	507aedeae1	v1.0.8	2025-05-22 06:26:37 +03:00
Deniz Şafak	c5faab4bd7	Add clearing preview cache option	2025-05-22 06:10:58 +03:00
Deniz Şafak	3278447d6a	Added a download tracker that displays informative messages	2025-05-22 06:03:56 +03:00
Deniz Şafak	a0e59564af	Ignore metadata and leding/trailing spaces when counting text length	2025-05-22 02:54:29 +03:00
Deniz Şafak	6e96fb6405	Fix previewed voice states when cancel	2025-05-22 02:42:45 +03:00
Deniz Şafak	f1cb92900c	Updated profile and voice mixer icons, better visibility and aesthetics in voice mixer	2025-05-22 02:26:17 +03:00
Deniz Şafak	065eaa4745	Added voice preview caching system	2025-05-22 00:26:27 +03:00
Deniz Şafak	082bb08e48	Removed `abogen_` prefix that was adding to converted books	2025-05-21 20:54:34 +03:00
Deniz Şafak	f286c4c6dc	Added new option: `Separate chapters audio format`	2025-05-21 20:03:36 +03:00
Deniz Şafak	669ef26667	Added extra metadata support for chaptered M4B files	2025-05-21 18:42:41 +03:00
Deniz Şafak	fd10aab6f3	Fixed voice preview player keeps open at the background	2025-05-21 04:54:13 +03:00
Deniz Şafak	0d7e746516	Update CHANGELOG	2025-05-20 04:30:59 +03:00
Deniz Şafak	2cb2f3dfb1	Fix NVML Shared library error	2025-05-20 04:23:22 +03:00
Deniz Şafak	578da66f34	Update GPU check logic	2025-05-20 04:11:17 +03:00
Deniz Şafak	814c171a90	Update GPU detection logic	2025-05-20 03:32:29 +03:00
Deniz Şafak	b3b420beec	Do not install CUDA in Windows if GPU is AMD	2025-05-20 02:48:02 +03:00
Deniz Şafak	93be50eda1	Add support for AMD in Linux	2025-05-20 02:46:43 +03:00
Deniz Şafak	9c44001601	Fix app icon issue in Linux	2025-05-15 21:22:18 +03:00
Deniz Şafak	e03336836b	Better sleep state handling for Linux	2025-05-15 21:15:47 +03:00
Deniz Şafak	b75277a3cb	Improved input box background color handling	2025-05-15 21:13:00 +03:00
Deniz ŞafakandGitHub	f611512747	Update CHANGELOG.md	2025-05-10 01:25:48 +03:00
Deniz Şafak	accb3efc54	v1.0.7	2025-05-10 01:24:22 +03:00
Deniz Şafak	f415c0d4d3	Fix ffmpeg error in Linux	2025-05-10 01:12:37 +03:00
Deniz Şafak	7fff2f154c	Fix [Errno 32] in Linux	2025-05-10 00:44:26 +03:00
Deniz Şafak	85481ad119	Update changelog and shortcut text	2025-05-10 00:28:15 +03:00
Deniz Şafak	143c9d9b30	Offer installation for linux	2025-05-10 00:21:57 +03:00
Deniz Şafak	5cfb8b4be7	Update readme, fix desktop shortcut in linux	2025-05-10 00:08:38 +03:00
Deniz Şafak	1b5b8e0e31	Add icon.png	2025-05-09 20:40:54 +03:00
Deniz Şafak	11caeedef5	Added `Add desktop shortcut` option to Linux version	2025-05-09 20:39:28 +03:00
Deniz Şafak	9c997c9616	Added `Save in a project folder with metadata` option, added `Go to folder` button	2025-05-09 19:34:32 +03:00
Deniz Şafak	ac8907041a	Improved PDF handling	2025-05-09 17:36:49 +03:00
Deniz Şafak	22086793ae	Improved process handling for subpprocess calls	2025-05-09 10:58:05 +03:00
Deniz Şafak	101012d9aa	Prevent cancellation if process is at 99%	2025-05-09 01:50:09 +03:00
Deniz Şafak	cab0a7631f	Improve chaptered audio generation by outputting directly as `m4b` instead of converting from `wav`	2025-05-09 01:29:14 +03:00
Deniz Şafak	375a185aef	Added `.opus` support as output format for generated audio files.	2025-05-08 20:43:44 +03:00
Deniz Şafak	a691b9af58	Added "Playing..." indicator for "Preview" button in the voice mixer	2025-05-08 16:38:24 +03:00
Deniz Şafak	311cdaeae1	Ignore chapter markers and single newlines when calculating text length	2025-05-08 16:29:43 +03:00
Deniz Şafak	4d0aabc13e	Update changelog	2025-05-08 15:51:04 +03:00
Deniz Şafak	b644da8556	Fix "No module named 'progress'" in Windows 10	2025-05-05 11:41:09 +03:00
Deniz Şafak	fa6e3fce1a	Fix "No module named 'progress'" in Windows 10	2025-05-05 11:26:01 +03:00
Deniz Şafak	8f8ad3ec26	v1.0.6	2025-05-04 15:23:25 +03:00
Deniz Şafak	67b35d1dfb	Add preview button to voice mixer	2025-05-04 15:10:08 +03:00
Deniz Şafak	15f1eb7f1e	Add chapter marker button, fix f-string, fix contnet before chapter not including	2025-05-04 13:53:03 +03:00
Deniz Şafak	146fcb3c1f	Restyle using black, improve m4b process handling	2025-05-04 11:39:54 +03:00
Deniz Şafak	412fb3bc7e	Update readme	2025-05-04 11:10:07 +03:00
Deniz ŞafakandGitHub	d9b6081a06	Merge pull request #13 from denizsafak/beta - 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.	2025-05-04 11:00:44 +03:00
Deniz ŞafakandGitHub	674fc14813	Merge branch 'main' into beta	2025-05-04 11:00:16 +03:00
Deniz Şafak	fa144561fb	Update changelog	2025-05-04 10:58:37 +03:00
Deniz Şafak	1d27f6fd2e	Improvements in documentation	2025-05-04 10:50:36 +03:00
Deniz Şafak	a03120d66f	Fix "cannot access local variable 'm4b_picked'", improve m4b handling	2025-05-04 02:07:34 +03:00
Deniz Şafak	68b44a3516	Add label for m4b output format, improvements	2025-05-04 00:51:56 +03:00
Deniz ŞafakandGitHub	3bbb88d446	Update Dockerfile	2025-05-04 00:14:01 +03:00
Deniz Şafak	a1ccd51ea0	Fix dockerfile	2025-05-04 00:13:33 +03:00
Deniz Şafak	13cf6f20a4	Added informative messages and improved error handling for ffmpeg	2025-05-04 00:03:53 +03:00
Deniz Şafak	4311ed51d4	Fix m4b error in seperate chapters	2025-05-03 23:40:01 +03:00
Deniz Şafak	9170d9ae3e	Update readme	2025-05-03 23:15:38 +03:00
Deniz Şafak	593d21675e	Update readme	2025-05-03 23:15:06 +03:00
Deniz Şafak	9aebdecc60	Fix progress error	2025-05-03 23:13:43 +03:00
Deniz ŞafakandGitHub	290d246e80	Merge pull request #10 from jborza/main Add chapter metadata	2025-05-03 23:01:00 +03:00
Deniz ŞafakandGitHub	5ac6e3bb2a	Merge pull request #11 from denizsafak/main Update beta branch	2025-05-03 22:57:27 +03:00
Deniz Şafak	6bf189312a	Add docker support, fix config dir	2025-05-03 22:55:41 +03:00
Juraj Borza	22fdccd78d	Merge branch 'main' of https://github.com/jborza/abogen	2025-05-03 19:34:39 +02:00
Juraj Borza	62aeaecf89	Removed a variable that was unused in m4b generation	2025-05-03 19:34:35 +02:00
Juraj BorzaandGitHub	a7a41fa4f6	Merge branch 'denizsafak:main' into main	2025-05-03 19:27:33 +02:00
Juraj Borza	1ca4d0d5f9	Merge branch 'main' of https://github.com/jborza/abogen	2025-05-03 19:26:46 +02:00
Juraj Borza	e09535fa83	Add chapter metadata - added m4b format, generating chapters info and converting via ffmpeg	2025-05-03 19:26:19 +02:00
Deniz Şafak	0863b25d82	Better approach for detemining the correct configuration folder for Linux and MacOS, using platformdirs	2025-05-03 18:31:45 +03:00
Deniz Şafak	b02416e068	Fix loading movie not playing again after first time	2025-05-03 16:00:12 +03:00
Deniz Şafak	8daa3cb3b5	Update readme about chapter markers	2025-05-03 12:09:26 +03:00
Deniz Şafak	20f31f82fd	v1.0.4	2025-05-02 21:18:07 +03:00
Deniz Şafak	d5388c62be	Fix enable/disable subtitle_combo fom voice mixer	2025-05-02 21:16:51 +03:00
Deniz Şafak	07a2fe2d5b	Fix new profile duplicating	2025-05-02 20:59:23 +03:00
Deniz ŞafakandGitHub	58d9073ace	Merge pull request #7 from jborza/main Updated development instructions in README	2025-05-02 20:17:17 +03:00
Deniz ŞafakandGitHub	2cbb2f8aa7	Merge pull request #8 from denizsafak/beta Imrpovements for voice mixer	2025-05-02 20:12:47 +03:00
Deniz Şafak	f7d8d5ccd8	Imrpovements for voice mixer	2025-05-02 20:10:28 +03:00
Juraj Borza	e7d479d846	use CPU conversion if GPU conversion is not available also in preview	2025-05-02 19:00:01 +02:00
Juraj Borza	036eed3142	also stopping the loading movie on preview cleanup	2025-05-02 18:58:38 +02:00
Juraj Borza	0d86d107e9	remove the animation from preview button on cleanup	2025-05-02 18:50:33 +02:00
Juraj Borza	56b336a529	Added 'pip install build' to development instructions, otherwise python -m build won't work	2025-05-02 18:28:17 +02:00
@@ -1 +1 @@
 .0.3
 .0.9