DEV Community: AlexMaryW

How to Split Audiobooks into Chapters for Free Using Chapterize-Audiobooks?

AlexMaryW — Tue, 22 Oct 2024 16:40:17 +0000

If you’re tired of dealing with large MP3 files and want to learn how to split audiobooks into chapters for free, this step-by-step guide will show you how to use Chapterize-Audiobooks effectively.

If you've ever purchased an audiobook only to find one huge mp3 file, you know how frustrating it can be. I’ve been there. Every time I restarted the app, I’d be thrown back to the beginning, struggling to find my place. It was such a headache that I eventually gave up on the book altogether.

Fortunately, there's a solution to this headache - Chapterize-Audiobooks! This open-source audiobook splitter available on GitHub allows you to easily convert one large MP3 file into chapterized MP3s. As a beginner, I faced some challenges while installing it, but with this tutorial, you’ll be able to split your audiobooks with ease.

Chapterize-Audiobooks is an open-source program with a command line interface that can split one big MP3 audiobook file into easy-to-navigate chapterized MP3s. Because this program is open source, it's available for free. Command line interface, on the other hand, means that you need to write instructions for the program in the terminal (Command Prompt application on Windows). Your instructions will have to follow a special syntax so that the software can understand and execute them.

Don't worry if you’re unfamiliar with these terms! This tutorial will walk you through the process step-by-step so you can effortlessly split your audiobooks into chapters.

How to Install Python, Git, and FFmpeg for Splitting Audiobooks

To use Chapterize-Adiobooks, you will need to install three things on your computer:

a programming language called Python;
a tool for managing code called Git;
and an audio processing tool called ffmpeg.

Let's begin with Python because it's the easiest one to install.

Open the terminal on your computer (Command Prompt application on Windows). The first thing you'll see in your terminal is a prompt* and it will look like this: C:\Users\your-username>. To check if Python is installed on your computer, type/copy the following line into your terminal and hit enter:
```
python --version
```
This line is a great example of the syntax you need to use to execute a program in the terminal. Usually, the program's name comes first and, then, your chosen options/parameters separated by spaces.
If Python is already set up on your computer, the terminal will display its version (e.g. Python 3.12.6) and you can move to installing Git.
If you don't have Python on your computer, Windows 10 will open Microsoft Store for you. There, you can download and install Python free of charge. When the installation's complete, type/copy the following line into your terminal and hit enter:
```
python --version
```
If the terminal displays Python's version (e.g. Python 3.12.6), the installation has been successful.

Now that we have Python, let's install Git.

You can get the Git installer for free from Git's official website.
When the download is finished, click on the file, and go through the installation process (you can safely keep clicking "Next" until the "Install" button appears).
Once Git is installed, restart your terminal before moving forward with this tutorial.

Two done, one to go! Here's how you install ffmpeg.

Download the zip file with source code for ffmpeg by clicking here.
Unpack the file. To do this you can use 7zip program or WinRAR.
Rename the unpacked folder to "ffmpeg".
Move the "ffmpeg" folder to your C drive. To find your C drive, you can type into your computer search bar "This PC", click it, and find "Windows (C:)" in the "Devices and drives" section.
Search for the Command Prompt application, right-click it, and select "Run as administrator" from the drop down menu.
When the terminal opens, your prompt should look like this: C:\WINDOWS\system32>.
Now we need to add ffmpeg's installation folder to the system's PATH so that Windows knows where to find ffmpeg when it's needed. To do that, type/copy the following line into your terminal and hit enter:
```
setx /m PATH "C:\ffmpeg\bin;%PATH%"
```
If you were successful, the terminal will display the following message: "SUCCESS: Specified value was saved". To proceed, you need to restart your computer.
When your computer restarts, you can double-check if ffmpeg is set up. To do so, run Command Prompt app as an administrator, type/copy the following line into your command line, and hit enter:
```
ffmpeg -version
```
If the installation was successful, the terminal will display ffmpeg's version, configuration, and libraries.

Great job! You're all set up to install Chapterize-Audiobooks!

*The prompt will reappear at the beginning of new line in your terminal when your computer has executed your command. For the sake of brevity, the prompt is omitted in the command lines in this tutorial. The prompt will no longer reappear when we start using Chapterize-Audiobooks.

How to Install Chapterize-Audiobooks

To install Chapterize-Audiobooks, you need to download the program from GitHub. Type/copy the following line into your terminal and hit enter:
```
git clone https://github.com/patrickenfuego/Chapterize-Audiobooks.git
```
This line copies the program's code from GitHub to your computer and you can use it to download any open source program. Please make sure to copy the correct GitHub link into your command.
When the prompt reappears in the terminal, it means the download was successful and we can proceed by going into the program's folder. Type/copy the following line into your terminal and hit enter:
```
cd Chapterize-Audiobooks
```
When the prompt reappears in this form: C:\Users\your-username\Chapterize-Audiobooks>, it means you have entered the correct folder on your computer. The next step is installing libraries necessary for Chapterize-Audiobooks to run correctly (listed in the "requirements.txt" file). A program called Pip* will handle this process by reading the file and installing the libraries included in it. To complete this step, type/copy the following line into your terminal and hit enter:
```
pip install -r requirements.txt
```

Congratulations! You have installed Chapterize-Audiobooks and are ready to split your audiobooks!

*Pip is installed together with Python so it's already set up on your computer.

How to Use Command Line to Split Audiobooks

Whenever you'd like to split an audiobook using Chapterize-Audiobooks, you need to first go into the program's folder. You can do this by typing/copying the following line into your terminal and hitting enter (if you have just installed the program, you're already in the correct folder and can move to step 3):
```
cd Chapterize-Audiobooks
```
When the prompt reappears in the following form: C:\Users\your-username\Chapterize-Audiobooks>, it means you have entered the folder and are ready to split your audiobook.
To split an audiobook, we need the audiobooks's file path, its location on your computer. The program will split your audiobook faster if the file is saved on your computer rather than on a peripheral device like a USB, memory card, etc. Although Windows doesn't provide the file path, here's how you can put it together:
- Right-click your audiobook's folder, choose "Properties", and copy the address shown in the "Location" section.
- Add your audiobook file's name with ".mp3" at the end of the file path, e.g. C:\Users\your-username\Desktop\audiobook\audiobook.mp3.
- If your audiobook's name contains spaces, replace them with hyphens (e.g. my-audiobook.mp3), or the terminal will misinterpret them.
Now, you're all set to split the audiobook. To use the Chapterize-Audiobooks program, your command line will have to include python (tells the terminal to use Python to run the program), chapterize_ab.py (the program file), and the audiobook's file path in single quotation marks (use the quotation marks, to avoid issues if your file path contains spaces). To split the audiobook, type the following line into your terminal, paste your file path, and hit enter:
```
  python chapterize_ab.py 'C:\Users\your-username\Desktop\audiobook\audiobook.mp3'
```
Now, the program will do its magic and split your monolithic MP3 into chapterized MP3 files. Please be patient with this process because the longer your audiobook, the longer the program will take to chapterize it (it might take an hour or more in certain cases).

How to Add Titles, Cover Art, etc., with Chapterize-Audiobooks

Chapterize-Audiobooks can do more than just split your audiobook. You can, for example, ask it to give your audiobook a title, add a cover art, or author's name. All available parameters can be found in the Usage and Examples sections of Chapterize-Audiobooks's readme.

The parameters in square brackets are optional and parameters in curly brackets are available options to choose from. You can add as many as you like and in an order that suits you by typing them together with the command line splitting the audiobook. For example, typing the following line and hitting enter will split an audiobook, add cover art to it, and the author's name:

python chapterize_ab.py 'your audiobook path' --title 'your audiobook's title' --cover_art 'path to the cover art' --author 'author's name'

Was this guide helpful? Do let me know in the comments and enjoy your chapterized audiobooks! 😃

Indexable Containers in Haskell

AlexMaryW — Sun, 11 Aug 2024 11:12:24 +0000

While learning Haskell, you will come across List, the most popular indexable container available in this programming language. However, as you dive deeper into Haskell, List's limitations, e.g. slow indexing or immutability, will become more and more pervasive. Although we cannot fix List's flaws, we can use alternative modules to achieve better performance and/or functionality. In this post, we will discuss List and two modules you can use instead, Data.Array and Data.Vector, aiming to collect essential knowledge on them in one place and differentiate between them.

List

List is one of the most basic data structures in every programming language and, if Haskell isn't your first programming language, you might already be familiar with it. Yet, Haskell's built-in List is rather special for three reasons:

Firstly, it can contain exclusively same-type elements (contrary to, e.g., lists in Python).
Secondly, it has performance characteristics of linked lists.
Lastly, as everything in Haskell, it is immutable.

> let longList = [1..50000] -- A List of 50,000 elements
> let elemAt50000 = longList !! 50000 -- Indexing into the last, 50,000th element (the operation is slow!)
> elemAt50000
50000

Listing 1: Creating a List containing 50,000 elements and indexing into the last element

Indexing into List can be slow because the program iterates from the first element to find the desired element. Interestingly, List can generate values as you index into it. This is caused by Haskell's being lazy and not evaluating elements until you try to read the value.

> let infiniteList = [1..] -- Creating an infinite List (you can do this because Haskell is a lazy programming language)
> let thisEvaluatesMillionElements = longList !! 1000000
> thisEvaluatesMillionElements
1000000

Listing 2: Creating an infinite List containing 50,000 elements and indexing into the last element

List is convenient to use because of its simplicity but performing certain operations on it is much more complicated than it would be for an Array or a Vector, e.g. copying. Hence, compared to the other two, List is slow and best suited for simpler purposes. You can use List if you don't need immediate access to each element, want to iterate from the first element, to avoid any additional dependencies, or to iterate on an infinite number of elements.

Array

In contrast to List, Array is a mutable data structure (except immutable IArray) that allows immediate access to its elements. Its main advantage is the amount of control it gives you over indexing. For example, you can index into Array by Int, Int32, Int64, and even Char. Furthermore, it supports lower and upper bounds, meaning you can assign any position to its first element. Hence, the first element can hold the 5th position and to access it you would have to index into 5. Another advantage Array has over List is StorableArray, a type that can be used with C functions and is available in the Array module.

> import Data.Array (Array, listArray, array, (!!))
> let arr = listArray (5, 10) "abcde" :: Array Int Char -- Creating an Array of Chars, indexed by Ints
> arr ! 6
'b'
> let charArr = array ('a', 'c') [('a', "I'm at index a"), ('b', "I'm at index b")] -- Creating an Array of Strings, indexed by Chars
> charArr ! 'b'
"I'm at index b"

Listing 3: Creating and reading Arrays with various index ranges and types

However, Array's advantages also lead to its disadvantages. Because Array grants you control over indexing, you cannot simply create an Array, you have to define its indexing as well. It is reasonable, then, that if you're working with an already existing Array, you need to always keep in mind which indexing types it implements.

> arr ! (4 :: Int)
*** Exception: Ix{Integer}.index: Index (4) out of range ((5,10))

> charArr ! (1 :: Int)
<interactive>: error:
    • Couldn't match expected type ‘Char’ with actual type ‘Int’

Listing 4: Examples of incorrect indexing into an Array

Combining mutability and O(1) indexability, Array is a powerful container and can serve complex purposes. It is also built into Haskell and recommended if you consider additional dependencies less than desirable.

If you want to learn more about Array, this tutorial on MMHaskell might be helpful.

Vector

As a data structure, Vector combines the best qualities of List and Array: a simple API and O(1) access to elements. Similarly to List, Vector is immutable (except for MVector which you can read on here) and can be indexed only by Int.

> import Data.Vector (fromList)
> let vec = fromList [1, 2, 3]
> vec
[1,2,3]

Listing 5: Creating a Vector from a List

However, Vector has features that distinguish it from List and Array:

it is growable, meaning that you can append elements to a Vector;
it supports loop fusion, which increases its efficiency (Mark Karpov has explained this process well in his blog).

> import Data.Vector.Mutable (new, write, read, grow)
> mvec <- new 5 :: IO (MVector RealWorld Char) -- Creating a Vector of Chars
> write mvec 6 'x'
*** Exception: index out of bounds (6,5)
> grown <- grow mvec 30                        -- Growing the Vector by 30 elements
> Data.Vector.Mutable.read grown 6
'x'

Listing 6: Mutating and growing a Vector

Please note that Vector is not built into Haskell. The package is available on Hackage. Just like Array, the Vector module offers a Data.Vector.Storable that is compatible with C functions.

Using Vector is recommended if you need Array's O(1) access, don't mind extra dependencies and lack of generic indexing, and want to perform actions too complex for lists or are looking for a mutable container (only when using MVector interface).

Conclusion

Familiarizing yourself with the containers available in a given programming language is a necessary aspect of the learning process. This post gathers the basic information on all three indexable Haskell containers, each with a different purpose, and possibly useful for your project. The table below summarizes the most important features of containers discussed in this post:

Feature	List	Array	Vector
Difficulty	low	high	medium
Built-In	yes	yes	no
Mutable	no	yes (except `IArray`)	no (except `MVector`)
Indexable by	`Int`	e.g. `Int`, `Word32`, `Bool`, or `Char`	`Int`

Happy coding!