v1.1.1

v1.1.0

.github/workflows/test_publish.yml

@@ -0,0 +1,61 @@
+name: Build multi-arch Docker Image
+
+on:
+  # Build and push
+  #release:
+  #  types: [published]
+  # Build only
+  #push:
+  #  branches: [main]
+  # TODO - enable build on pull requests if build times can be reduced
+  # pull_request:
+  workflow_dispatch:
+
+env:
+  IMAGE_REPOSITORY: ghcr.io/denizsafak/abogen
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Login to Github Container Registry
+      # Only if we need to push an image
+      if: ${{ github.event_name == 'release' && github.event.action == 'published' }}
+      uses: docker/login-action@v3
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+    # Setup for buildx
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v3
+
+    - name: Set up Docker Buildx
+      id: buildx
+      uses: docker/setup-buildx-action@v3
+
+    # Debugging information
+    - name: Docker info
+      run: docker info
+
+    - name: Buildx inspect
+      run: docker buildx inspect
+
+    # Build and (optionally) push the image
+    - name: Build image
+      uses: docker/build-push-action@v6
+      with:
+        context: ./abogen
+        file: ./abogen/Dockerfile
+        # platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
+        platforms: linux/amd64,linux/arm64
+        # Only push if we are publishing a release
+        push: ${{ github.event_name == 'release' && github.event.action == 'published' }}
+        # Use a 'temp' tag, that won't be pushed, for non-release builds
+        tags: ${{ env.IMAGE_REPOSITORY }}:${{ github.event.release.tag_name || 'temp' }}
+        # Use a cache to reduce build times
+        cache-to: type=gha,mode=max
+        cache-from: type=gha

CHANGELOG.md

@@ -1,3 +1,22 @@
+# v1.1.1
+- Fixed adding wrong file in queue for EPUB and PDF files, ensuring the correct file is added to the queue.
+- Reformatted the code using Black.
+
+# v1.1.0
+- Added queue system for processing multiple items, allowing users to add multiple files and process them in a queue, mentioned by @jborza in #30 (Special thanks to @jborza for implementing this feature in PR #35)
+- Added a feature that allows selecting multiple items in book handler (in right click menu) by @jborza in #31, that fixes #28
+- Added dark theme support, allowing users to switch between light and dark themes in the settings.
+- Added auto-accept system to the chapter options dialog in conversion process, allowing the dialog to auto-accept after a certain time if no action is taken.
+- Added new option: `Configure max lines in log window` that allows configuring the maximum number of lines to display in the log window.
+- Improvements in documentation and code.
+
+# 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

README.md

@@ -17,9 +17,27 @@ 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?` <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.
+
+#### 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)
+mkdir abogen && cd abogen
+python -m venv venv
+venv\Scripts\activate
+
 # For NVIDIA GPUs:
 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
 
@@ -29,47 +47,50 @@ pip install torch torchvision torchaudio --index-url https://download.pytorch.or
 # Install abogen
 pip install abogen
 ```
-Alternatively, for an easier setup on Windows:
-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).)
 
 ### Mac
 ```bash
 # Install espeak-ng
 brew install espeak-ng
 
+# Create a virtual environment (recommended)
+mkdir abogen && cd abogen
+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)
+mkdir abogen && cd abogen
+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:
-pip uninstall torch # After installing abogen, we need to uninstall the existing torch package
-pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.4
+# 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.
 
 > 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.
@@ -80,6 +101,7 @@ If you installed using pip, you can simply run the following command to start Ab
 ```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?`
@@ -97,33 +119,58 @@ abogen
 
 Here’s Abogen in action: in this demo, it processes ∼3,000 characters of text in just 11 seconds and turns it into 3 minutes and 28 seconds of audio, and I have a low-end **RTX 2060 Mobile laptop GPU**. Your results may vary depending on your hardware.
 
-## `Key Features`
-- **Supported formats**: `ePub`, `PDF`, or `.TXT` files (or use built-in text editor)
-- **Speed**: Adjust speech rate from `0.1x` to `2.0x`
-- **Voices**: First letter of the language code (e.g., `a` for American English, `b` for British English, etc.), second letter is for `m` for male and `f` for female.
-- **Voice mixer**: Create custom voices by mixing different voice models with a profile system.
-- **Generate subtitles**: `Disabled`, `Sentence`, `Sentence + Comma`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry)
-- **Output formats**: `.WAV`, `.FLAC`, `.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**: Configures the maximum number of words per subtitle entry.
-    - **Separate chapters audio format**: Configures the audio format for separate chapters (e.g., `WAV`, `FLAC`, `MP3`, `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 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`.
+## `Configuration`
+
+| Options | Description |
+|---------|-------------|
+| **Input Box** | Drag and drop `ePub`, `PDF`, or `.TXT` files (or use built-in text editor) |
+| **Queue options** | Add multiple files to a queue and process them in batch, with individual settings for each file. See [Queue mode](#queue-mode) for more details. |
+| **Speed** | Adjust speech rate from `0.1x` to `2.0x` |
+| **Select Voice** | 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. See [Voice Mixer](#voice-mixer) for more details. |
+| **Voice preview** | Listen to the selected voice before processing. |
+| **Generate subtitles** | `Disabled`, `Sentence`, `Sentence + Comma`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry) |
+| **Output voice format** | `.WAV`, `.FLAC`, `.MP3`, `.OPUS (best compression)` 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)) |
+| **Output subtitle format** | Configures the subtitle format as `SRT (standard)`, `ASS (wide)`, `ASS (narrow)`, `ASS (centered wide)`, or `ASS (centered narrow)`. |
+| **Replace single newlines with spaces** | Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks. |
+| **Save location** | `Save next to input file`, `Save to desktop`, or `Choose output folder` |
+
+| Book handler options | Description |
+|---------|-------------|
+| **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. |
+| **Create a merged version** | Create a single audio file that combines all chapters. (If `Save each chapter separately` is disabled, this option will be the default behavior.) |
+| **Save in a project folder with metadata** | Save the converted items in a project folder with available metadata files. |
+
+| Menu options | Description |
+|---------|-------------|
+| **Theme** | Change the application's theme using `System`, `Light`, or `Dark` options. |
+| **Configure max words per subtitle** | Configures the maximum number of words per subtitle entry. |
+| **Configure max lines in log window** | Configures the maximum number of lines to display in the log window. |
+| **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 temporary files** | Deletes temporary files created during the conversion or preview. |
+| **Check for updates at startup** | Automatically checks for updates when the program starts. |
 
 ## `Voice Mixer`
 <img title="Abogen Voice Mixer" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/voice_mixer.png'>
 
 With voice mixer, you can create custom voices by mixing different voice models. You can adjust the weight of each voice and save your custom voice as a profile for future use. The voice mixer allows you to create unique and personalized voices. (Huge thanks to [@jborza](https://github.com/jborza) for making this possible through his contributions in [#5](https://github.com/denizsafak/abogen/pull/5))
 
+## `Queue Mode`
+<img title="Abogen queue mode" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/queue.png'>
+
+Abogen supports **queue mode**, allowing you to add multiple files to a processing queue. This is useful if you want to convert several files in one batch.
+
+- You can add text files (`.txt`) directly using the **Add files** button in the Queue Manager. To add PDF or EPUB files, use the input box in the main window and click the **Add to Queue** button.
+- Each file in the queue keeps the configuration settings that were active when it was added. Changing the main window configuration afterward does **not** affect files already in the queue.
+- You can view each file's configuration by hovering over them.
+
+Abogen will process each item in the queue automatically, saving outputs as configured.
+> Special thanks to [@jborza](https://github.com/jborza) for adding queue mode in PR [#35](https://github.com/denizsafak/abogen/pull/35)
+
 ## `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:
 
@@ -147,6 +194,17 @@ When you process the text file, Abogen will detect these markers automatically a
 
 ![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 for `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`
 ```
@@ -164,11 +222,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
@@ -221,12 +281,12 @@ Abogen is a standalone project, but it is inspired by and shares some similariti
 - [ebook2audiobook](https://github.com/DrewThomasson/ebook2audiobook): Convert ebooks to audiobooks with chapters and metadata using dynamic AI models and voice cloning
 
 ## `Roadmap`
-- [ ] Add OCR scan feature for PDF files using docling.
+- [ ] Add OCR scan feature for PDF files using docling/teserract.
 - [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. (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.
+- [x] Add dark mode.
 
 ## `Troubleshooting`
 If you encounter any issues while running Abogen, try launching it from the command line with:

abogen/VERSION

@@ -1 +1 @@
-1.0.8
+1.1.1

abogen/assets/settings.svg

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg height="800px" width="800px" version="1.1" id="_x32_" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+	 viewBox="0 0 512 512"  xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#808080;}
+</style>
+<g>
+	<path class="st0" d="M502.325,307.303l-39.006-30.805c-6.215-4.908-9.665-12.429-9.668-20.348c0-0.084,0-0.168,0-0.252
+		c-0.014-7.936,3.44-15.478,9.667-20.396l39.007-30.806c8.933-7.055,12.093-19.185,7.737-29.701l-17.134-41.366
+		c-4.356-10.516-15.167-16.86-26.472-15.532l-49.366,5.8c-7.881,0.926-15.656-1.966-21.258-7.586
+		c-0.059-0.06-0.118-0.119-0.177-0.178c-5.597-5.602-8.476-13.36-7.552-21.225l5.799-49.363
+		c1.328-11.305-5.015-22.116-15.531-26.472L337.004,1.939c-10.516-4.356-22.646-1.196-29.701,7.736l-30.805,39.005
+		c-4.908,6.215-12.43,9.665-20.349,9.668c-0.084,0-0.168,0-0.252,0c-7.935,0.014-15.477-3.44-20.395-9.667L204.697,9.675
+		c-7.055-8.933-19.185-12.092-29.702-7.736L133.63,19.072c-10.516,4.356-16.86,15.167-15.532,26.473l5.799,49.366
+		c0.926,7.881-1.964,15.656-7.585,21.257c-0.059,0.059-0.118,0.118-0.178,0.178c-5.602,5.598-13.36,8.477-21.226,7.552
+		l-49.363-5.799c-11.305-1.328-22.116,5.015-26.472,15.531L1.939,174.996c-4.356,10.516-1.196,22.646,7.736,29.701l39.006,30.805
+		c6.215,4.908,9.665,12.429,9.668,20.348c0,0.084,0,0.167,0,0.251c0.014,7.935-3.44,15.477-9.667,20.395L9.675,307.303
+		c-8.933,7.055-12.092,19.185-7.736,29.701l17.134,41.365c4.356,10.516,15.168,16.86,26.472,15.532l49.366-5.799
+		c7.882-0.926,15.656,1.965,21.258,7.586c0.059,0.059,0.118,0.119,0.178,0.178c5.597,5.603,8.476,13.36,7.552,21.226l-5.799,49.364
+		c-1.328,11.305,5.015,22.116,15.532,26.472l41.366,17.134c10.516,4.356,22.646,1.196,29.701-7.736l30.804-39.005
+		c4.908-6.215,12.43-9.665,20.348-9.669c0.084,0,0.168,0,0.251,0c7.936-0.014,15.478,3.44,20.396,9.667l30.806,39.007
+		c7.055,8.933,19.185,12.093,29.701,7.736l41.366-17.134c10.516-4.356,16.86-15.168,15.532-26.472l-5.8-49.366
+		c-0.926-7.881,1.965-15.656,7.586-21.257c0.059-0.059,0.119-0.119,0.178-0.178c5.602-5.597,13.36-8.476,21.225-7.552l49.364,5.799
+		c11.305,1.328,22.117-5.015,26.472-15.531l17.134-41.365C514.418,326.488,511.258,314.358,502.325,307.303z M281.292,329.698
+		c-39.68,16.436-85.172-2.407-101.607-42.087c-16.436-39.68,2.407-85.171,42.087-101.608c39.68-16.436,85.172,2.407,101.608,42.088
+		C339.815,267.771,320.972,313.262,281.292,329.698z"/>
+</g>
+</svg>

abogen/book_handler.py

@@ -111,7 +111,7 @@ class HandlerDialog(QDialog):
         # Build treeview
         self.treeWidget = QTreeWidget(self)
         self.treeWidget.setHeaderHidden(True)
-        self.treeWidget.setSelectionMode(QTreeWidget.SingleSelection)
+        self.treeWidget.setSelectionMode(QTreeWidget.ExtendedSelection)
         self.treeWidget.setContextMenuPolicy(Qt.CustomContextMenu)
         self.treeWidget.customContextMenuRequested.connect(self.on_tree_context_menu)
 
@@ -161,6 +161,7 @@ class HandlerDialog(QDialog):
         self.treeWidget.expandAll()
         if self.treeWidget.topLevelItemCount() > 0:
             self.treeWidget.setCurrentItem(self.treeWidget.topLevelItem(0))
+            self.treeWidget.setFocus()
 
         # Update checkbox states
         self._update_checkbox_states()
@@ -849,6 +850,12 @@ class HandlerDialog(QDialog):
             has_parents = True
         self.treeWidget.setRootIsDecorated(has_parents)
 
+    def _update_checkbox_states(self):
+        """Update the checkbox states based on the current checked chapters."""
+        for i in range(self.treeWidget.topLevelItemCount()):
+            item = self.treeWidget.topLevelItem(i)
+            self._update_item_checkbox_state(item)
+
     def _build_epub_tree_from_nav(
         self, nav_nodes, parent_item, seen_content_hashes=None
     ):
@@ -990,10 +997,21 @@ class HandlerDialog(QDialog):
                     bookmark_item.setData(0, Qt.UserRole, page_id)
                     # 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)
+                        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)
+                        bookmark_item.setFlags(
+                            bookmark_item.flags() & ~Qt.ItemIsUserCheckable
+                        )
                     # map for uncategorized pages
                     self.bookmark_items_map[page_num] = bookmark_item
 
@@ -1020,10 +1038,21 @@ class HandlerDialog(QDialog):
                         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.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)
+                            page_item.setFlags(
+                                page_item.flags() & ~Qt.ItemIsUserCheckable
+                            )
 
                         added_pages.add(sub_page_num)
 
@@ -1031,11 +1060,15 @@ class HandlerDialog(QDialog):
 
         covered_pages = set(added_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]
+        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
+            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()
@@ -1048,7 +1081,9 @@ class HandlerDialog(QDialog):
             # 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)
+                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)
 
@@ -1074,7 +1109,9 @@ class HandlerDialog(QDialog):
             # 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)
+                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)
 
@@ -1494,7 +1531,9 @@ 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"):
+        if self.book_metadata["publisher"] or self.book_metadata.get(
+            "publication_year"
+        ):
             pub_info = []
             if self.book_metadata["publisher"]:
                 pub_info.append(f"Published by {self.book_metadata['publisher']}")
@@ -1536,7 +1575,9 @@ class HandlerDialog(QDialog):
             try:
                 author_items = self.book.get_metadata("DC", "creator")
                 if author_items:
-                    metadata["authors"] = [author[0] for author in author_items if len(author) > 0]
+                    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}")
 
@@ -1560,7 +1601,7 @@ class HandlerDialog(QDialog):
                 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)
+                    year_match = re.search(r"\b(19|20)\d{2}\b", date_str)
                     if year_match:
                         metadata["publication_year"] = year_match.group(0)
                     else:
@@ -1600,12 +1641,12 @@ class HandlerDialog(QDialog):
                 # 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)
+                    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)
+                    year_match = re.search(r"D:(\d{4})", date_str)
                     if year_match:
                         metadata["publication_year"] = year_match.group(1)
 
@@ -1637,11 +1678,15 @@ class HandlerDialog(QDialog):
         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
+        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'}"
+        chapter_text = (
+            f"{total_chapters} {'Chapters' if self.file_type == 'epub' else 'Pages'}"
+        )
 
         # Format metadata tags
         metadata_tags = [
@@ -1649,7 +1694,9 @@ class HandlerDialog(QDialog):
             f"<<METADATA_ARTIST:{authors_text}>>",
             f"<<METADATA_ALBUM:{title} ({chapter_text})>>",
             f"<<METADATA_YEAR:{year}>>",
-            f"<<METADATA_ALBUM_ARTIST:{album_artist}>>"
+            f"<<METADATA_ALBUM_ARTIST:{album_artist}>>",
+            f"<<METADATA_COMPOSER:Narrator>>",
+            f"<<METADATA_GENRE:Audiobook>>",
         ]
 
         return "\n".join(metadata_tags)
@@ -1721,7 +1768,10 @@ class HandlerDialog(QDialog):
                     if text:
                         all_content.append(text)
                         included_text_ids.add(page_id)
-            return metadata_tags + "\n\n" + "\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():
@@ -1779,7 +1829,10 @@ class HandlerDialog(QDialog):
                         included_text_ids.add(identifier)
             iterator += 1
 
-        return metadata_tags + "\n\n" + "\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)
@@ -1807,8 +1860,33 @@ class HandlerDialog(QDialog):
     def get_save_as_project(self):
         return self.save_as_project
 
+    def check_selected_items(self):
+        self.set_selected_items_checked(True)
+
+    def uncheck_selected_items(self):
+        self.set_selected_items_checked(False)
+
+    def set_selected_items_checked(self, state: bool):
+        print(f"Checking selected items: {state}")
+        self.treeWidget.blockSignals(True)
+        for item in self.treeWidget.selectedItems():
+            if item.flags() & Qt.ItemIsUserCheckable:
+                item.setCheckState(0, Qt.Checked if state else Qt.Unchecked)
+        self.treeWidget.blockSignals(False)
+        self._update_checked_set_from_tree()
+
     def on_tree_context_menu(self, pos):
         item = self.treeWidget.itemAt(pos)
+        # multi-select context menu
+        if self.treeWidget.selectedItems() and len(self.treeWidget.selectedItems()) > 1:
+            menu = QMenu(self)
+            action = menu.addAction("Select")
+            action.triggered.connect(self.check_selected_items)
+            action = menu.addAction("Clear")
+            action.triggered.connect(self.uncheck_selected_items)
+            menu.exec_(self.treeWidget.mapToGlobal(pos))
+            return
+
         if (
             not item
             or item.childCount() == 0

abogen/constants.py

@@ -1,4 +1,4 @@
-from utils import get_version
+from abogen.utils import get_version
 
 # Program Information
 PROGRAM_NAME = "abogen"
@@ -8,6 +8,9 @@ PROGRAM_DESCRIPTION = (
 GITHUB_URL = "https://github.com/denizsafak/abogen"
 VERSION = get_version()
 
+# Settings
+CHAPTER_OPTIONS_COUNTDOWN = 30  # Countdown seconds for chapter options
+
 # Language description mapping
 LANGUAGE_DESCRIPTIONS = {
     "a": "American English",
@@ -102,3 +105,28 @@ SAMPLE_VOICE_TEXTS = {
     "p": "Este é um exemplo da voz selecionada.",
     "z": "这是所选语音的示例。",
 }
+
+COLORS = {
+    "BLUE": "#007dff",
+    "RED": "#c0392b",
+    "GREEN": "#42ad4a",
+    "GREEN_BG": "rgba(66, 173, 73, 0.1)",
+    "GREEN_BG_HOVER": "rgba(66, 173, 73, 0.15)",
+    "GREEN_BORDER": "#42ad4a",
+    "BLUE_BG": "rgba(0, 102, 255, 0.05)",
+    "BLUE_BG_HOVER": "rgba(0, 102, 255, 0.1)",
+    "BLUE_BORDER_HOVER": "#6ab0de",
+    "YELLOW_BACKGROUND": "rgba(255, 221, 51, 0.40)",
+    "GREY_BACKGROUND": "rgba(128, 128, 128, 0.15)",
+    "RED_BACKGROUND": "rgba(232, 78, 60, 0.15)",
+    "RED_BG": "rgba(232, 78, 60, 0.10)",
+    "RED_BG_HOVER": "rgba(232, 78, 60, 0.15)",
+    # Theme palette colors
+    "DARK_BG": "#202326",
+    "DARK_BASE": "#141618",
+    "DARK_ALT": "#2c2f31",
+    "DARK_BUTTON": "#292c30",
+    "DARK_DISABLED": "#535353",
+    "LIGHT_BG": "#eff0f1",
+    "LIGHT_DISABLED": "#9a9999",
+}

abogen/conversion.py

@@ -6,13 +6,19 @@ 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.QtCore import QThread, pyqtSignal, Qt, QTimer
 from PyQt5.QtWidgets import QCheckBox, QVBoxLayout, QDialog, QLabel, QDialogButtonBox
 import soundfile as sf
-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
+from abogen.utils import clean_text, create_process
+from abogen.constants import (
+    PROGRAM_NAME,
+    LANGUAGE_DESCRIPTIONS,
+    SAMPLE_VOICE_TEXTS,
+    COLORS,
+    CHAPTER_OPTIONS_COUNTDOWN,
+)
+from abogen.voice_formulas import get_new_voice
+import abogen.hf_tracker as hf_tracker
 import static_ffmpeg
 import threading  # for efficient waiting
 import subprocess
@@ -61,7 +67,7 @@ class ChapterOptionsDialog(QDialog):
         self.merge_at_end_checkbox = QCheckBox("Create a merged version at the end")
 
         # Set default states
-        self.save_separately_checkbox.setChecked(True)
+        self.save_separately_checkbox.setChecked(False)
         self.merge_at_end_checkbox.setChecked(True)
 
         # Connect checkbox state change signal
@@ -72,14 +78,40 @@ class ChapterOptionsDialog(QDialog):
         layout.addWidget(self.save_separately_checkbox)
         layout.addWidget(self.merge_at_end_checkbox)
 
+        # Countdown label
+        self.countdown_seconds = CHAPTER_OPTIONS_COUNTDOWN
+        self.countdown_label = QLabel(
+            f"Auto-accepting in {self.countdown_seconds} seconds..."
+        )
+        self.countdown_label.setStyleSheet(f"color: {COLORS['GREEN']};")
+        layout.addWidget(self.countdown_label)
+
         # Add OK button
         button_box = QDialogButtonBox(QDialogButtonBox.Ok)
         button_box.accepted.connect(self.accept)
         layout.addWidget(button_box)
 
+        # Timer for countdown
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._on_timer_tick)
+        self._timer.start(1000)  # 1 second interval
+
+        # Store button_box for later use
+        self._button_box = button_box
+
         # Initialize merge checkbox state
         self.update_merge_checkbox_state()
 
+    def _on_timer_tick(self):
+        self.countdown_seconds -= 1
+        if self.countdown_seconds > 0:
+            self.countdown_label.setText(
+                f"Auto-accepting in {self.countdown_seconds} seconds..."
+            )
+        else:
+            self._timer.stop()
+            self._button_box.accepted.emit()  # Simulate OK click
+
     def update_merge_checkbox_state(self):
         # Enable merge checkbox only if save separately is checked
         self.merge_at_end_checkbox.setEnabled(self.save_separately_checkbox.isChecked())
@@ -131,6 +163,7 @@ class ConversionThread(QThread):
         start_time,
         total_char_count,
         use_gpu=True,
+        from_queue=False,
     ):  # Add use_gpu parameter
         super().__init__()
         self._chapter_options_event = threading.Event()
@@ -144,7 +177,10 @@ class ConversionThread(QThread):
         self.output_folder = output_folder
         self.subtitle_mode = subtitle_mode
         self.cancel_requested = False
+        self.should_cancel = False
+        self.process = None
         self.output_format = output_format
+        self.from_queue = from_queue
         self.start_time = start_time  # Store start_time
         self.total_char_count = total_char_count  # Use passed total character count
         self.processed_char_count = 0  # Initialize processed character count
@@ -157,6 +193,188 @@ 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"
@@ -165,15 +383,22 @@ class ConversionThread(QThread):
             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
-            display_file = self.display_path if self.display_path else self.file_name
+
+            # Use file_name for logs if from_queue, otherwise use display_path if available
+            if getattr(self, "from_queue", False):
+                display_file = self.file_name
+            else:
+                display_file = (
+                    self.display_path if self.display_path else self.file_name
+                )
+
             self.log_updated.emit(f"- Input File: {display_file}")
 
             # Use file size string passed from GUI
             if hasattr(self, "file_size_str"):
                 self.log_updated.emit(f"- File size: {self.file_size_str}")
 
-            self.log_updated.emit(f"- Total characters: {self.total_char_count:,}")
+            self.log_updated.emit(f"- Total characters: {int(self.total_char_count):,}")
 
             self.log_updated.emit(
                 f"- Language: {self.lang_code} ({LANGUAGE_DESCRIPTIONS.get(self.lang_code, 'Unknown')})"
@@ -182,6 +407,9 @@ 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")
@@ -200,8 +428,10 @@ class ConversionThread(QThread):
                         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}")
+                    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(
@@ -295,7 +525,13 @@ class ConversionThread(QThread):
             save_chapters_separately = getattr(self, "save_chapters_separately", False)
             chapters_out_dir = None
             suffix = ""
+
+            # Use file_name for logs if from_queue, otherwise use display_path if available
+            if getattr(self, "from_queue", False):
+                base_path = self.file_name
+            else:
                 base_path = self.display_path if self.display_path else self.file_name
+
             base_name = os.path.splitext(os.path.basename(base_path))[0]
             if self.save_option == "Save to Desktop":
                 parent_dir = user_desktop_dir()
@@ -501,64 +737,72 @@ 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')
+                    separate_format = getattr(self, "separate_chapters_format", "wav")
 
                     chapter_out_path = os.path.join(
                         chapters_out_dir, f"{chapter_filename}.{separate_format}"
                     )
-                    if separate_format == "opus":
-                        static_ffmpeg.add_paths()
-                        proc = create_process(
-                            [
-                                "ffmpeg",
-                                "-y",
-                                "-thread_queue_size", "32768", # Increased thread_queue_size for chapter opus
-                                "-f",
-                                "f32le",
-                                "-ar",
-                                "24000",
-                                "-ac",
-                                "1",
-                                "-i",
-                                "pipe:0",
-                                "-c:a",
-                                "libopus",
-                                "-b:a",
-                                "24000",
+
+                    # Process audio segments using the unified function
+                    success, chapter_out_path = self._process_audio_segments(
+                        chapter_audio_segments,
                         chapter_out_path,
-                            ],
-                            stdin=subprocess.PIPE,
-                            text=False  # Ensure binary stdin for audio data
-                        )
-                        proc.stdin.write(chapter_audio.astype("float32").tobytes())
-                        proc.stdin.close()
-                        proc.wait()
-                    else:
-                        sf.write(
-                            chapter_out_path,
-                            chapter_audio,
-                            24000,
-                            format=separate_format,
+                        separate_format,
+                        use_ffmpeg=(separate_format in ["opus", "m4b"]),
                     )
 
-                    # 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"
+                    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 = subtitle_format in (
+                                "ass_centered_wide",
+                                "ass_centered_narrow",
+                            )
+                            is_narrow = subtitle_format in (
+                                "ass_narrow",
+                                "ass_centered_narrow",
+                            )
+                            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
@@ -569,7 +813,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",
                             )
                         )
@@ -594,70 +838,90 @@ class ConversionThread(QThread):
             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_data_np = self.np.concatenate(audio_segments)
+                self.log_updated.emit("\nFinalizing audio file...")
 
                 out_dir = parent_dir
                 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":
-                    final_out_path = self._generate_m4b_with_chapters(audio_data_np, chapters_time, base_filepath_no_ext)
-                elif intended_output_format == "opus":
-                    static_ffmpeg.add_paths()
-                    opus_out_path = f"{base_filepath_no_ext}.opus"
-                    ffmpeg_cmd_opus = [
-                        "ffmpeg", "-y",
-                        "-thread_queue_size", "32768", # Increased thread_queue_size
-                        "-f", "f32le", "-ar", "24000", "-ac", "1", "-i", "pipe:0",
-                        "-c:a", "libopus", "-b:a", "24000", # Original bitrate
-                        opus_out_path,
-                    ]
-                    try:
-                        process = create_process(ffmpeg_cmd_opus, stdin=subprocess.PIPE, text=False)  # Ensure binary stdin
-                        process.stdin.write(audio_data_np.astype("float32").tobytes())
-                        process.stdin.close()
-                        if process.wait() == 0:
-                            final_out_path = opus_out_path
+                    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:
-                            self.log_updated.emit(("Opus conversion failed.", "red"))
-                            final_out_path = None 
-                    except Exception as e_opus:
-                        self.log_updated.emit((f"Error during Opus conversion: {str(e_opus)}", "red"))
-                        final_out_path = None
-                else: # For other formats like wav
-                    standard_out_path = f"{base_filepath_no_ext}.{intended_output_format}"
-                    try:
-                        sf.write(standard_out_path, audio_data_np, 24000, format=intended_output_format)
-                        final_out_path = standard_out_path
-                    except Exception as e_sf:
-                        self.log_updated.emit((f"Failed to write audio file {standard_out_path}: {str(e_sf)}", "red"))
+                    # 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":
-                        srt_path = os.path.splitext(final_out_path)[0] + ".srt"
-                        with open(srt_path, "w", encoding="utf-8", errors="replace") as srt_file:
-                            for i, (start, end, text) in enumerate(subtitle_entries, 1):
+                        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
+                            is_centered = subtitle_format in (
+                                "ass_centered_wide",
+                                "ass_centered_narrow",
+                            )
+                            is_narrow = subtitle_format in (
+                                "ass_narrow",
+                                "ass_centered_narrow",
+                            )
+                            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: {final_out_path}\n\nSubtitle saved to: {srt_path}",
+                                f"\nAudiobook saved to: {final_out_path}\n\nSubtitle saved to: {subtitle_path}",
                                 "green",
                             ),
                             final_out_path,
                         )
                     else:
                         self.conversion_finished.emit(
-                            (f"Audiobook saved to: {final_out_path}", "green"), final_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)
+                    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(
                     (
@@ -680,86 +944,131 @@ class ConversionThread(QThread):
         self.waiting_for_user_input = False
         self._chapter_options_event.set()
 
-    def _generate_m4b_with_chapters(self, audio_data_np, chapters_time, base_filepath_no_ext):
+    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"
-        
-        if not chapters_time or len(chapters_time) <= 1:
-            self.log_updated.emit(
-                (
-                    "File contains only one chapter or no chapters were detected. Audio will be saved as a standard .wav file instead.\n",
-                    "red",
-                )
-            )
-            try:
-                sf.write(final_wav_path, audio_data_np, 24000, format="wav")
-                return final_wav_path
-            except Exception as e_wav_single:
-                self.log_updated.emit((f"Failed to save single/no chapter audio as WAV: {str(e_wav_single)}", "red"))
-                return None
-
         output_m4b_path = f"{base_filepath_no_ext}.m4b"
         chapters_info_path = f"{base_filepath_no_ext}_chapters.txt"
 
+        # 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") # Using milliseconds for precision
+                    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['chapter']}\n\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()
-            ffmpeg_cmd = [
-                "ffmpeg", "-y",
-                "-thread_queue_size", "32768", # Increased thread_queue_size
-                "-f", "f32le", "-ar", "24000", "-ac", "1", "-i", "pipe:0",
-                "-i", chapters_info_path,
-                "-map", "0:a",
-                "-map_metadata", "1", 
-                "-map_chapters", "1",
-                # Add metadata tags
-                "-metadata", "composer=Narrator",
-                "-metadata", "genre=Audiobook",
-                # Extract metadata from text markers if available
-                *self._extract_and_add_metadata_tags_to_ffmpeg_cmd(),
-                "-c:a", "aac",
-                "-q:a", "2", # Quality-based VBR for better quality control (lower = better, range 0.1-2)
-                "-movflags", "+faststart+use_metadata_tags",  # Added for better compatibility
-                output_m4b_path,
+            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
             ]
 
-            self.log_updated.emit(f"Generating audio with chapters...\n")
-
-            process = create_process(ffmpeg_cmd, stdin=subprocess.PIPE, text=False)  # Ensure binary stdin
-            process.stdin.write(audio_data_np.astype("float32").tobytes())
-            process.stdin.close()
-            return_code = process.wait()
-
-            if return_code == 0:
-                return output_m4b_path
-            else:
-                self.log_updated.emit(
-                    (f"FFmpeg failed to create M4B (return code {return_code}).\n\nFalling back to WAV.\n", "red")
+            # 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,
             )
-                sf.write(final_wav_path, audio_data_np, 24000, format="wav")
-                return final_wav_path
 
-        except Exception as e:
-            self.log_updated.emit((f"Error during M4B generation: {str(e)}.\n\nFalling back to WAV.\n", "red"))
-            try:
-                sf.write(final_wav_path, audio_data_np, 24000, format="wav")
-                return final_wav_path
-            except Exception as e_wav_fallback:
-                self.log_updated.emit((f"Critical error: Failed to save fallback WAV: {str(e_wav_fallback)}\n", "red"))
-                return None
-        finally:
+            # Clean up the temporary chapter metadata file
             if os.path.exists(chapters_info_path):
                 try:
                     os.remove(chapters_info_path)
-                except Exception as e_clean:
-                    self.log_updated.emit((f"Warning: Could not delete temporary chapter file {chapters_info_path}: {e_clean}", "orange"))
+                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"""
@@ -772,10 +1081,14 @@ class ConversionThread(QThread):
         else:
             try:
                 encoding = detect_encoding(self.file_name)
-                with open(self.file_name, "r", encoding=encoding, errors="replace") as file:
+                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}")
+                self.log_updated.emit(
+                    f"Warning: Could not read file for metadata extraction: {e}"
+                )
                 return []
 
         # Extract metadata tags using regex
@@ -784,13 +1097,23 @@ class ConversionThread(QThread):
         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]
 
-        # Add title metadata
+        # Use file_name for logs if from_queue, otherwise use display_path if available
+        if getattr(self, "from_queue", False):
+            filename = os.path.splitext(os.path.basename(self.file_name))[0]
+        else:
+            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=Dinginliğin Gücü"])
+            metadata_options.extend(["-metadata", f"title={title_match.group(1)}"])
         else:
             metadata_options.extend(["-metadata", f"title={filename}"])
 
@@ -812,15 +1135,32 @@ class ConversionThread(QThread):
         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)}"])
+            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
 
@@ -832,6 +1172,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
     ):
@@ -918,11 +1266,46 @@ 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 = (
-            False  # Also release the wait if we're waiting for input
-        )
+        self.should_cancel = True
+        self.waiting_for_user_input = False
+        # Terminate subprocess if running
+        if self.process:
+            try:
+                self.process.terminate()
+            except Exception:
+                pass
 
 
 class VoicePreviewThread(QThread):
@@ -948,7 +1331,9 @@ class VoicePreviewThread(QThread):
         self.use_gpu = use_gpu
 
         # Cache location for preview audio
-        self.cache_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME, "preview_cache")
+        self.cache_dir = os.path.join(
+            tempfile.gettempdir(), PROGRAM_NAME, "preview_cache"
+        )
         os.makedirs(self.cache_dir, exist_ok=True)
 
         # Calculate cache path
@@ -958,7 +1343,9 @@ class VoicePreviewThread(QThread):
         """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]}"
+            voice_id = (
+                f"voice_formula_{hashlib.md5(self.voice.encode()).hexdigest()[:8]}"
+            )
         else:
             voice_id = self.voice
 
@@ -1032,7 +1419,9 @@ class PlayAudioThread(QThread):
         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")
+                self.error.emit(
+                    "Audio playback error: The audio system was not properly initialized"
+                )
             else:
                 self.error.emit(f"Audio playback error: {str(e)}")
 
@@ -1042,6 +1431,7 @@ class PlayAudioThread(QThread):
         # 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()

abogen/hf_tracker.py

@@ -1,16 +1,20 @@
 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)
@@ -22,7 +26,10 @@ def tracked_hf_hub_download(*args, **kwargs):
         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.")
+                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:
@@ -32,5 +39,7 @@ def tracked_hf_hub_download(*args, **kwargs):
             print(msg, flush=True)
     return hf_hub_download(*args, **kwargs)
 
+
 import huggingface_hub
+
 huggingface_hub.hf_hub_download = tracked_hf_hub_download

abogen/is_nvidia.py

@@ -1,16 +1,22 @@
 import gpustat
 
+
 def check():
     try:
         stats = gpustat.new_query()
     except Exception:
         return False
 
+    nvidia_keywords = ["nvidia", "rtx", "gtx", "quadro", "tesla", "titan", "mx"]
     for gpu in stats.gpus:
-        print(gpu.name)
-        if 'nvidia' in gpu.name.lower():
+        name = gpu.name.lower()
+        if any(keyword in name for keyword in nvidia_keywords):
             return True
     return False
 
+
 if __name__ == "__main__":
+    stats = gpustat.new_query()
+    for gpu in stats.gpus:
+        print(gpu.name)
     print(check())

abogen/main.py

@@ -3,12 +3,13 @@ import sys
 import platform
 from PyQt5.QtWidgets import QApplication
 from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import qInstallMessageHandler, QtMsgType
 
 # Add the directory to Python path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__)))
-from gui import abogen
-from utils import get_resource_path
-from constants import PROGRAM_NAME, VERSION
+from abogen.gui import abogen
+from abogen.utils import get_resource_path
+from abogen.constants import PROGRAM_NAME, VERSION
 
 # Set environment variables for AMD ROCm
 os.environ["MIOPEN_FIND_MODE"] = "FAST"
@@ -24,6 +25,26 @@ if sys.stderr is None:
 if platform.system() == "Darwin" and platform.processor() == "arm":
     os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 
+
+# Custom message handler to filter out specific Qt warnings
+def qt_message_handler(mode, context, message):
+    if "Wayland does not support QWindow::requestActivate()" in message:
+        return  # Suppress this specific message
+    if "setGrabPopup called with a parent, QtWaylandClient" in message:
+        return
+    if mode == QtMsgType.QtWarningMsg:
+        print(f"Qt Warning: {message}")
+    elif mode == QtMsgType.QtCriticalMsg:
+        print(f"Qt Critical: {message}")
+    elif mode == QtMsgType.QtFatalMsg:
+        print(f"Qt Fatal: {message}")
+    elif mode == QtMsgType.QtInfoMsg:
+        print(f"Qt Info: {message}")
+
+
+# Install the custom message handler
+qInstallMessageHandler(qt_message_handler)
+
 # Set application ID for Windows taskbar icon
 if platform.system() == "Windows":
     import ctypes

abogen/queue_manager_gui.py

@@ -0,0 +1,553 @@
+# a simple window with a list of items in the queue, no checkboxes
+# button to remove an item from the queue
+# button to clear the queue
+
+from PyQt5.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QDialogButtonBox,
+    QPushButton,
+    QListWidget,
+    QListWidgetItem,
+    QFileIconProvider,
+    QLabel,
+    QWidget,
+    QSizePolicy,
+)
+from PyQt5.QtCore import QFileInfo, Qt
+from abogen.constants import COLORS
+from copy import deepcopy
+from PyQt5.QtGui import QFontMetrics
+
+
+class ElidedLabel(QLabel):
+    def __init__(self, text, parent=None):
+        super().__init__(text, parent)
+        self._full_text = text
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+
+    def setText(self, text):
+        self._full_text = text
+        super().setText(text)
+        self.update()
+
+    def resizeEvent(self, event):
+        metrics = QFontMetrics(self.font())
+        elided = metrics.elidedText(self._full_text, Qt.ElideRight, self.width())
+        super().setText(elided)
+        super().resizeEvent(event)
+
+    def fullText(self):
+        return self._full_text
+
+
+class QueueListItemWidget(QWidget):
+    def __init__(self, file_name, char_count):
+        super().__init__()
+        layout = QHBoxLayout()
+        layout.setContentsMargins(12, 0, 6, 0)
+        layout.setSpacing(0)
+        import os
+
+        name_label = ElidedLabel(os.path.basename(file_name))
+        char_label = QLabel(f"Chars: {char_count}")
+        char_label.setStyleSheet(f"color: {COLORS['LIGHT_DISABLED']};")
+        char_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        char_label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
+        layout.addWidget(name_label, 1)
+        layout.addWidget(char_label, 0)
+        self.setLayout(layout)
+
+
+class DroppableQueueListWidget(QListWidget):
+    def __init__(self, parent_dialog):
+        super().__init__()
+        self.parent_dialog = parent_dialog
+        self.setAcceptDrops(True)
+        # Overlay for drag hover
+        self.drag_overlay = QLabel("", self)
+        self.drag_overlay.setAlignment(Qt.AlignCenter)
+        self.drag_overlay.setStyleSheet(
+            f"border:2px dashed {COLORS['BLUE_BORDER_HOVER']}; border-radius:5px; padding:20px; background:{COLORS['BLUE_BG_HOVER']};"
+        )
+        self.drag_overlay.setVisible(False)
+        self.drag_overlay.setAttribute(Qt.WA_TransparentForMouseEvents, True)
+
+    def dragEnterEvent(self, event):
+        if event.mimeData().hasUrls():
+            for url in event.mimeData().urls():
+                if url.isLocalFile() and url.toLocalFile().lower().endswith(".txt"):
+                    self.drag_overlay.resize(self.size())
+                    self.drag_overlay.setVisible(True)
+                    event.acceptProposedAction()
+                    return
+        self.drag_overlay.setVisible(False)
+        event.ignore()
+
+    def dragMoveEvent(self, event):
+        if event.mimeData().hasUrls():
+            for url in event.mimeData().urls():
+                if url.isLocalFile() and url.toLocalFile().lower().endswith(".txt"):
+                    event.acceptProposedAction()
+                    return
+        event.ignore()
+
+    def dragLeaveEvent(self, event):
+        self.drag_overlay.setVisible(False)
+        event.accept()
+
+    def dropEvent(self, event):
+        self.drag_overlay.setVisible(False)
+        if event.mimeData().hasUrls():
+            file_paths = [
+                url.toLocalFile()
+                for url in event.mimeData().urls()
+                if url.isLocalFile() and url.toLocalFile().lower().endswith(".txt")
+            ]
+            if file_paths:
+                self.parent_dialog.add_files_from_paths(file_paths)
+                event.acceptProposedAction()
+            else:
+                event.ignore()
+        else:
+            event.ignore()
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        if hasattr(self, "drag_overlay"):
+            self.drag_overlay.resize(self.size())
+
+
+class QueueManager(QDialog):
+    def __init__(self, parent, queue: list, title="Queue Manager", size=(600, 700)):
+        super().__init__()
+        self.queue = queue
+        self._original_queue = deepcopy(
+            queue
+        )  # Store a deep copy of the original queue
+        self.parent = parent
+        layout = QVBoxLayout()
+        layout.setContentsMargins(15, 15, 15, 15)  # set main layout margins
+        layout.setSpacing(12)  # set spacing between widgets in main layout
+        # list of queued items
+        self.listwidget = DroppableQueueListWidget(self)
+        self.listwidget.setSelectionMode(QListWidget.ExtendedSelection)
+        self.listwidget.setAlternatingRowColors(True)
+        self.listwidget.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.listwidget.customContextMenuRequested.connect(self.show_context_menu)
+        # Add informative instructions at the top
+        instructions = QLabel(
+            "<h2>How Queue Works?</h2>"
+            "You can add text files (.txt) directly using the '<b>Add files</b>' button below. "
+            "To add PDF or EPUB files, use the input box in the main window and click the <b>'Add to Queue'</b> button. "
+            "Each file in the queue keeps the configuration settings active when it was added. "
+            "Changing the main window configuration afterward <b>does not</b> affect files already in the queue. "
+            "You can view each file's configuration by hovering over them."
+        )
+        instructions.setAlignment(Qt.AlignLeft)
+        instructions.setWordWrap(True)
+        instructions.setStyleSheet("margin-bottom: 8px;")
+        layout.addWidget(instructions)
+        # Overlay label for empty queue
+        self.empty_overlay = QLabel(
+            "Drag and drop your text files here or use the 'Add files' button.",
+            self.listwidget,
+        )
+        self.empty_overlay.setAlignment(Qt.AlignCenter)
+        self.empty_overlay.setStyleSheet(
+            f"color: {COLORS['LIGHT_DISABLED']}; background: transparent; padding: 20px;"
+        )
+        self.empty_overlay.setWordWrap(True)
+        self.empty_overlay.setAttribute(Qt.WA_TransparentForMouseEvents, True)
+        self.empty_overlay.hide()
+        # add queue items to the list
+        self.process_queue()
+
+        button_row = QHBoxLayout()
+        button_row.setContentsMargins(0, 0, 0, 0)  # optional: no margins for button row
+        button_row.setSpacing(7)  # set spacing between buttons
+        # Add files button
+        add_files_button = QPushButton("Add files")
+        add_files_button.setFixedHeight(40)
+        add_files_button.clicked.connect(self.add_more_files)
+        button_row.addWidget(add_files_button)
+
+        # Remove button
+        self.remove_button = QPushButton("Remove selected")
+        self.remove_button.setFixedHeight(40)
+        self.remove_button.clicked.connect(self.remove_item)
+        button_row.addWidget(self.remove_button)
+
+        # Clear button
+        self.clear_button = QPushButton("Clear Queue")
+        self.clear_button.setFixedHeight(40)
+        self.clear_button.clicked.connect(self.clear_queue)
+        button_row.addWidget(self.clear_button)
+
+        layout.addLayout(button_row)
+        layout.addWidget(self.listwidget)
+
+        # Connect selection change to update button state
+        self.listwidget.currentItemChanged.connect(self.update_button_states)
+        self.listwidget.itemSelectionChanged.connect(self.update_button_states)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self)
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+
+        layout.addWidget(buttons)
+
+        self.setLayout(layout)
+
+        self.setWindowTitle(title)
+        self.resize(*size)
+
+        self.update_button_states()
+
+    def process_queue(self):
+        """Process the queue items."""
+        self.listwidget.clear()
+        if not self.queue:
+            self.empty_overlay.resize(self.listwidget.size())
+            self.empty_overlay.show()
+            self.update_button_states()
+            return
+        else:
+            self.empty_overlay.hide()
+        icon_provider = QFileIconProvider()
+        for item in self.queue:
+            # Only show the file name, not the full path
+            file_name = item.file_name
+            display_name = file_name
+            import os
+
+            if os.path.sep in file_name:
+                display_name = os.path.basename(file_name)
+            # Get icon for the file
+            icon = icon_provider.icon(QFileInfo(file_name))
+            list_item = QListWidgetItem()
+            # Set tooltip with detailed info
+            output_folder = getattr(item, "output_folder", "")
+            tooltip = (
+                f"<b>Path:</b> {file_name}<br>"
+                f"<b>Language:</b> {getattr(item, 'lang_code', '')}<br>"
+                f"<b>Speed:</b> {getattr(item, 'speed', '')}<br>"
+                f"<b>Voice:</b> {getattr(item, 'voice', '')}<br>"
+                f"<b>Save Option:</b> {getattr(item, 'save_option', '')}<br>"
+            )
+            if output_folder not in (None, "", "None"):
+                tooltip += f"<b>Output Folder:</b> {output_folder}<br>"
+            tooltip += (
+                f"<b>Subtitle Mode:</b> {getattr(item, 'subtitle_mode', '')}<br>"
+                f"<b>Output Format:</b> {getattr(item, 'output_format', '')}<br>"
+                f"<b>Characters:</b> {getattr(item, 'total_char_count', '')}<br>"
+                f"<b>Replace Single Newlines:</b> {getattr(item, 'replace_single_newlines', False)}"
+            )
+            list_item.setToolTip(tooltip)
+            list_item.setIcon(icon)
+            # Use custom widget for display
+            char_count = getattr(item, "total_char_count", 0)
+            widget = QueueListItemWidget(file_name, char_count)
+            self.listwidget.addItem(list_item)
+            self.listwidget.setItemWidget(list_item, widget)
+        self.update_button_states()
+
+    def remove_item(self):
+        items = self.listwidget.selectedItems()
+        if not items:
+            return
+        from PyQt5.QtWidgets import QMessageBox
+
+        # Remove by index to ensure correct mapping
+        rows = sorted([self.listwidget.row(item) for item in items], reverse=True)
+        # Warn user if removing multiple files
+        if len(rows) > 1:
+            reply = QMessageBox.question(
+                self,
+                "Confirm Remove",
+                f"Are you sure you want to remove {len(rows)} selected items from the queue?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No,
+            )
+            if reply != QMessageBox.Yes:
+                return
+        for row in rows:
+            if 0 <= row < len(self.queue):
+                del self.queue[row]
+        self.process_queue()
+        self.update_button_states()
+
+    def clear_queue(self):
+        from PyQt5.QtWidgets import QMessageBox
+
+        if len(self.queue) > 1:
+            reply = QMessageBox.question(
+                self,
+                "Confirm Clear Queue",
+                f"Are you sure you want to clear {len(self.queue)} items from the queue?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No,
+            )
+            if reply != QMessageBox.Yes:
+                return
+        self.queue.clear()
+        self.listwidget.clear()
+        self.empty_overlay.resize(
+            self.listwidget.size()
+        )  # Ensure overlay is sized correctly
+        self.empty_overlay.show()  # Show the overlay when queue is empty
+        self.update_button_states()
+
+    def get_queue(self):
+        return self.queue
+
+    def get_current_attributes(self):
+        # Fetch current attribute values from the parent abogen GUI
+        attrs = {}
+        parent = self.parent
+        if parent is not None:
+            # lang_code: use parent's get_voice_formula and get_selected_lang
+            if hasattr(parent, "get_voice_formula") and hasattr(
+                parent, "get_selected_lang"
+            ):
+                voice_formula = parent.get_voice_formula()
+                attrs["lang_code"] = parent.get_selected_lang(voice_formula)
+                attrs["voice"] = voice_formula
+            else:
+                attrs["lang_code"] = getattr(parent, "selected_lang", "")
+                attrs["voice"] = getattr(parent, "selected_voice", "")
+            # speed
+            if hasattr(parent, "speed_slider"):
+                attrs["speed"] = parent.speed_slider.value() / 100.0
+            else:
+                attrs["speed"] = getattr(parent, "speed", 1.0)
+            # save_option
+            attrs["save_option"] = getattr(parent, "save_option", "")
+            # output_folder
+            attrs["output_folder"] = getattr(parent, "selected_output_folder", "")
+            # subtitle_mode
+            if hasattr(parent, "get_actual_subtitle_mode"):
+                attrs["subtitle_mode"] = parent.get_actual_subtitle_mode()
+            else:
+                attrs["subtitle_mode"] = getattr(parent, "subtitle_mode", "")
+            # output_format
+            attrs["output_format"] = getattr(parent, "selected_format", "")
+            # total_char_count
+            attrs["total_char_count"] = getattr(parent, "char_count", "")
+            # replace_single_newlines
+            attrs["replace_single_newlines"] = getattr(
+                parent, "replace_single_newlines", False
+            )
+        else:
+            # fallback: empty values
+            attrs = {
+                k: ""
+                for k in [
+                    "lang_code",
+                    "speed",
+                    "voice",
+                    "save_option",
+                    "output_folder",
+                    "subtitle_mode",
+                    "output_format",
+                    "total_char_count",
+                    "replace_single_newlines",
+                ]
+            }
+        return attrs
+
+    def add_files_from_paths(self, file_paths):
+        from abogen.utils import calculate_text_length
+        from PyQt5.QtWidgets import QMessageBox
+        import os
+
+        current_attrs = self.get_current_attributes()
+        duplicates = []
+        for file_path in file_paths:
+
+            class QueueItem:
+                pass
+
+            item = QueueItem()
+            item.file_name = file_path
+            for attr, value in current_attrs.items():
+                setattr(item, attr, value)
+            # Read file content and calculate total_char_count using calculate_text_length
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                    file_content = f.read()
+                item.total_char_count = calculate_text_length(file_content)
+            except Exception:
+                item.total_char_count = 0
+            # Prevent adding duplicate items to the queue (check all attributes)
+            is_duplicate = False
+            for queued_item in self.queue:
+                if (
+                    getattr(queued_item, "file_name", None)
+                    == getattr(item, "file_name", None)
+                    and getattr(queued_item, "lang_code", None)
+                    == getattr(item, "lang_code", None)
+                    and getattr(queued_item, "speed", None)
+                    == getattr(item, "speed", None)
+                    and getattr(queued_item, "voice", None)
+                    == getattr(item, "voice", None)
+                    and getattr(queued_item, "save_option", None)
+                    == getattr(item, "save_option", None)
+                    and getattr(queued_item, "output_folder", None)
+                    == getattr(item, "output_folder", None)
+                    and getattr(queued_item, "subtitle_mode", None)
+                    == getattr(item, "subtitle_mode", None)
+                    and getattr(queued_item, "output_format", None)
+                    == getattr(item, "output_format", None)
+                    and getattr(queued_item, "total_char_count", None)
+                    == getattr(item, "total_char_count", None)
+                    and getattr(queued_item, "replace_single_newlines", False)
+                    == getattr(item, "replace_single_newlines", False)
+                ):
+                    is_duplicate = True
+                    break
+            if is_duplicate:
+                duplicates.append(os.path.basename(file_path))
+                continue
+            self.queue.append(item)
+        if duplicates:
+            QMessageBox.warning(
+                self,
+                "Duplicate Item(s)",
+                f"Skipping {len(duplicates)} file(s) with the same attributes, already in the queue.",
+            )
+        self.process_queue()
+        self.update_button_states()
+
+    def add_more_files(self):
+        from PyQt5.QtWidgets import QFileDialog
+        from abogen.utils import calculate_text_length  # import the function
+
+        # Only allow .txt files
+        files, _ = QFileDialog.getOpenFileNames(
+            self, "Select .txt files", "", "Text Files (*.txt)"
+        )
+        if not files:
+            return
+        self.add_files_from_paths(files)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        if hasattr(self, "empty_overlay"):
+            self.empty_overlay.resize(self.listwidget.size())
+
+    def update_button_states(self):
+        # Enable Remove if at least one item is selected, else disable
+        if hasattr(self, "remove_button"):
+            selected_count = len(self.listwidget.selectedItems())
+            self.remove_button.setEnabled(selected_count > 0)
+            if selected_count > 1:
+                self.remove_button.setText(f"Remove selected ({selected_count})")
+            else:
+                self.remove_button.setText("Remove selected")
+        # Disable Clear if queue is empty
+        if hasattr(self, "clear_button"):
+            self.clear_button.setEnabled(bool(self.queue))
+
+    def show_context_menu(self, pos):
+        from PyQt5.QtWidgets import QMenu, QAction
+        from PyQt5.QtGui import QDesktopServices
+        from PyQt5.QtCore import QUrl
+        import os
+
+        global_pos = self.listwidget.viewport().mapToGlobal(pos)
+        selected_items = self.listwidget.selectedItems()
+        menu = QMenu(self)
+        if len(selected_items) == 1:
+            # Add Remove action
+            remove_action = QAction("Remove this item", self)
+            remove_action.triggered.connect(self.remove_item)
+            menu.addAction(remove_action)
+
+            # Add Open file action
+            open_file_action = QAction("Open file", self)
+
+            def open_file():
+                from PyQt5.QtWidgets import QMessageBox
+
+                item = selected_items[0]
+                display_name = item.text()
+                for q in self.queue:
+                    if os.path.basename(q.file_name) == display_name:
+                        if not os.path.exists(q.file_name):
+                            QMessageBox.warning(
+                                self, "File Not Found", f"The file does not exist."
+                            )
+                            return
+                        QDesktopServices.openUrl(QUrl.fromLocalFile(q.file_name))
+                        break
+
+            open_file_action.triggered.connect(open_file)
+            menu.addAction(open_file_action)
+
+            # Add Go to folder action
+            go_to_folder_action = QAction("Go to folder", self)
+
+            def go_to_folder():
+                from PyQt5.QtWidgets import QMessageBox
+
+                item = selected_items[0]
+                display_name = item.text()
+                for q in self.queue:
+                    if os.path.basename(q.file_name) == display_name:
+                        if not os.path.exists(q.file_name):
+                            QMessageBox.warning(
+                                self, "File Not Found", f"The file does not exist."
+                            )
+                            return
+                        folder = os.path.dirname(q.file_name)
+                        if os.path.exists(folder):
+                            QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
+                        break
+
+            go_to_folder_action.triggered.connect(go_to_folder)
+            menu.addAction(go_to_folder_action)
+
+        elif len(selected_items) > 1:
+            remove_action = QAction(f"Remove selected ({len(selected_items)})", self)
+            remove_action.triggered.connect(self.remove_item)
+            menu.addAction(remove_action)
+        # Always add Clear Queue
+        clear_action = QAction("Clear Queue", self)
+        clear_action.triggered.connect(self.clear_queue)
+        menu.addAction(clear_action)
+        menu.exec_(global_pos)
+
+    def accept(self):
+        # Accept: keep changes
+        super().accept()
+
+    def reject(self):
+        # Cancel: restore original queue
+        from PyQt5.QtWidgets import QMessageBox
+
+        # Warn if user changed a lot (e.g., more than 1 items difference)
+        original_count = len(self._original_queue)
+        current_count = len(self.queue)
+        if abs(original_count - current_count) > 1:
+            reply = QMessageBox.question(
+                self,
+                "Confirm Cancel",
+                f"Are you sure you want to cancel and discard all changes?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No,
+            )
+            if reply != QMessageBox.Yes:
+                return
+        self.queue.clear()
+        self.queue.extend(deepcopy(self._original_queue))
+        super().reject()
+
+    def keyPressEvent(self, event):
+        from PyQt5.QtCore import Qt
+
+        if event.key() == Qt.Key_Delete:
+            self.remove_item()
+        else:
+            super().keyPressEvent(event)

abogen/queued_item.py

@@ -0,0 +1,16 @@
+# represents a queued item - book, chapters, voice, etc.
+from dataclasses import dataclass
+
+
+@dataclass
+class QueuedItem:
+    file_name: str
+    lang_code: str
+    speed: float
+    voice: str
+    save_option: str
+    output_folder: str
+    subtitle_mode: str
+    output_format: str
+    total_char_count: int
+    replace_single_newlines: bool = False

abogen/utils.py

@@ -105,15 +105,17 @@ def clean_text(text, *args, **kwargs):
 
 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')
+        formatter = logging.Formatter("%(message)s")
         handler.setFormatter(formatter)
         root.addHandler(handler)
         root.setLevel(logging.INFO)
@@ -156,6 +158,7 @@ def create_process(cmd, stdin=None, text=True, capture_output=False):
 
     # 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
@@ -174,7 +177,9 @@ def create_process(cmd, stdin=None, text=True, capture_output=False):
                         break
                     try:
                         # Try to decode binary data for display
-                        sys.stdout.write(chunk.decode(default_encoding, errors='replace'))
+                        sys.stdout.write(
+                            chunk.decode(default_encoding, errors="replace")
+                        )
                         sys.stdout.flush()
                     except Exception:
                         pass
@@ -217,20 +222,34 @@ def calculate_text_length(text):
 
 
 def get_gpu_acceleration(enabled):
+    try:
+        import torch
         from torch.cuda import is_available
 
         if not enabled:
             return "CUDA GPU available but using CPU.", False
-
         if is_available():
             return "CUDA GPU available and enabled.", True
-    return "CUDA GPU is not available. Using CPU.", False
+        # Gather more diagnostic info if CUDA is not available
+        try:
+            cuda_devices = torch.cuda.device_count()
+            cuda_error = (
+                torch.cuda.get_device_name(0)
+                if cuda_devices > 0
+                else "No devices found"
+            )
+        except Exception as e:
+            cuda_error = str(e)
+        return f"CUDA GPU is not available. Using CPU. ({cuda_error})", False
+    except Exception as e:
+        return f"Error checking CUDA GPU: {e}", False
 
 
 def prevent_sleep_start():
     system = platform.system()
     if system == "Windows":
         import ctypes
+
         ctypes.windll.kernel32.SetThreadExecutionState(
             0x80000000 | 0x00000001 | 0x00000040
         )
@@ -238,19 +257,22 @@ def prevent_sleep_start():
         _sleep_procs["Darwin"] = create_process(["caffeinate"])
     elif system == "Linux":
         # use a sleep that never exits so inhibition stays active
-        _sleep_procs["Linux"] = create_process([
+        _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:

abogen/voice_formula_gui.py

@@ -24,16 +24,20 @@ from PyQt5.QtWidgets import (
     QMenu,
     QAction,
     QComboBox,
+    QApplication,
 )
 from PyQt5.QtCore import Qt, QTimer, QPoint, QRect, QSize
-from PyQt5.QtGui import QPixmap, QIcon, QColor
-from constants import (
+from PyQt5.QtGui import QPixmap, QIcon
+from abogen.constants import (
     VOICES_INTERNAL,
     SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
     LANGUAGE_DESCRIPTIONS,
+    COLORS,
 )
-from utils import get_resource_path
-from voice_profiles import (
+import re
+import platform
+from abogen.utils import get_resource_path
+from abogen.voice_profiles import (
     load_profiles,
     save_profiles,
     delete_profile,
@@ -221,6 +225,21 @@ class VoiceMixer(QWidget):
         self.slider.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
         self.slider.setFixedWidth(SLIDER_WIDTH)
 
+        # Fix slider in Windows
+        if platform.system() == "Windows":
+            appstyle = QApplication.instance().style().objectName().lower()
+            if appstyle != "windowsvista":
+                # Set custom groove color for disabled state using COLORS["GREY_BACKGROUND"]
+                self.slider.setStyleSheet(
+                    f"""
+                    QSlider::groove:vertical:disabled {{
+                        background: {COLORS.get("GREY_BACKGROUND")};
+                        width: 4px;
+                        border-radius: 4px;
+                    }}
+                """
+                )
+
         # Connect controls
         self.slider.valueChanged.connect(lambda val: self.spin_box.setValue(val / 100))
         self.spin_box.valueChanged.connect(
@@ -271,9 +290,9 @@ class HoverLabel(QLabel):
         self.delete_button = QPushButton("×", self)
         self.delete_button.setFixedSize(16, 16)
         self.delete_button.setStyleSheet(
-            """
-            QPushButton {
-                background-color: #ff5555;
+            f"""
+            QPushButton {{
+                background-color: {COLORS.get("RED")};
                 color: white;
                 border-radius: 7px;
                 font-weight: bold;
@@ -281,10 +300,10 @@ class HoverLabel(QLabel):
                 border: none;
                 padding: 0px;
                 margin: 0px;
-            }
-            QPushButton:hover {
+            }}
+            QPushButton:hover {{
                 background-color: red;
-            }
+            }}
             """
         )
         # Make sure the entire button is clickable, not just the text
@@ -313,7 +332,9 @@ class VoiceFormulaDialog(QDialog):
         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)
+            self._original_mixed_voice_state = getattr(
+                parent, "mixed_voice_state", None
+            )
         profiles = load_profiles()
         self._virtual_new_profile = False
         if not profiles:
@@ -350,6 +371,11 @@ class VoiceFormulaDialog(QDialog):
         profile_layout.addLayout(header_layout)
         # Profile list
         self.profile_list = QListWidget()
+        self.profile_list.setSelectionMode(QListWidget.SingleSelection)
+        self.profile_list.setSelectionBehavior(QListWidget.SelectRows)
+        self.profile_list.setStyleSheet(
+            "QListWidget::item:selected { background: palette(highlight); color: palette(highlighted-text); }"
+        )
         icon = QIcon(get_resource_path("abogen.assets", "profile.png"))
         if self._virtual_new_profile:
             item = QListWidgetItem(icon, "New profile")
@@ -738,7 +764,7 @@ class VoiceFormulaDialog(QDialog):
                 percentage = weight / total * 100
                 # Make the voice name bold and include percentage
                 voice_label = HoverLabel(
-                    f'<b><span style="color:#007dff">{name}: {percentage:.1f}%</span></b>',
+                    f'<b><span style="color:{COLORS.get("BLUE")}">{name}: {percentage:.1f}%</span></b>',
                     name,
                 )
                 voice_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
@@ -953,6 +979,19 @@ class VoiceFormulaDialog(QDialog):
             return
         super().closeEvent(event)
 
+    def _parse_rgba_to_qcolor(self, rgba_str):
+        from PyQt5.QtCore import Qt
+        from PyQt5.QtGui import QColor
+
+        """Helper to convert 'rgba(R,G,B,A_float)' string to QColor."""
+        match = re.match(r"rgba\((\d+),\s*(\d+),\s*(\d+),\s*([\d.]+)\)", rgba_str)
+        if match:
+            r, g, b = int(match.group(1)), int(match.group(2)), int(match.group(3))
+            a_float = float(match.group(4))
+            a_int = int(a_float * 255)
+            return QColor(r, g, b, a_int)
+        return Qt.GlobalColor.transparent
+
     def mark_profile_modified(self):
         item = self.profile_list.currentItem()
         if item and not item.text().startswith("*"):
@@ -1052,7 +1091,7 @@ class VoiceFormulaDialog(QDialog):
             self, "Import Profiles", "", "JSON Files (*.json)"
         )
         if path:
-            from voice_profiles import load_profiles, save_profiles
+            from abogen.voice_profiles import load_profiles, save_profiles
 
             # Try to read the file and count profiles
             try:
@@ -1339,23 +1378,23 @@ class VoiceFormulaDialog(QDialog):
                 self.profile_list.setItemWidget(item, widget)
 
     def update_profile_list_colors(self):
+        from PyQt5.QtCore import Qt
+
         profiles = load_profiles()
         for i in range(self.profile_list.count()):
             item = self.profile_list.item(i)
             name = item.text().lstrip("*")
             if self._virtual_new_profile and name == "New profile":
-                color = QColor("#ffff00")  # yellow
-                color.setAlpha(64)  # Set transparency
-                item.setBackground(color)
+                color = self._parse_rgba_to_qcolor(COLORS.get("YELLOW_BACKGROUND"))
+                item.setData(Qt.BackgroundRole, color)
             elif item.text().startswith("*"):
-                color = QColor("#ffff00")  # yellow
-                color.setAlpha(64)  # Set transparency
-                item.setBackground(color)
+                color = self._parse_rgba_to_qcolor(COLORS.get("YELLOW_BACKGROUND"))
+                item.setData(Qt.BackgroundRole, color)
             else:
-                item.setBackground(self.profile_list.palette().base().color()) # Use default list item background
-
+                item.setData(
+                    Qt.BackgroundRole, self.profile_list.palette().base().color()
+                )
                 weights = profiles.get(name, {}).get("voices", [])
-                # Defensive: only sum if weights is a list of (voice, weight) pairs
                 total = 0
                 if isinstance(weights, list):
                     for entry in weights:
@@ -1366,9 +1405,8 @@ class VoiceFormulaDialog(QDialog):
                         ):
                             total += entry[1]
                 if total == 0:
-                    color = QColor("#ff0000")  # red
-                    color.setAlpha(64)  # Set transparency
-                    item.setBackground(color)
+                    color = self._parse_rgba_to_qcolor(COLORS.get("RED_BACKGROUND"))
+                    item.setData(Qt.BackgroundRole, color)
         self.update_profile_save_buttons()
 
     def preview_current_mix(self):

abogen/voice_formulas.py

@@ -1,5 +1,5 @@
 import re
-from constants import VOICES_INTERNAL
+from abogen.constants import VOICES_INTERNAL
 
 
 # Calls parsing and loads the voice to gpu or cpu

abogen/voice_profiles.py

@@ -1,6 +1,6 @@
 import os
 import json
-from utils import get_user_config_path
+from abogen.utils import get_user_config_path
 
 
 def _get_profiles_path():

demo/README.md

@@ -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.

demo/convert.py

@@ -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)

demo/demo.ass

@@ -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.

demo/demo.srt

@@ -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.
-