DEV Community: longtk26

Subtitle to Audio Tutorial

longtk26 — Sun, 18 Jan 2026 16:17:50 +0000

Subtitle to Audio Tutorial

Hi everyone! In this tutorial, we will explore how to convert subtitles into audio using text-to-speech (TTS) technology. This process can be particularly useful for creating audiobooks, podcasts, or enhancing accessibility for video content.

Subtitle to Audio Tutorial
- Table of Contents
- Introduction
- Workflow Overview
- Problems with workflow
  - 1. Limited execution time of lambda functions
  - 2. Limited resources within lambda functions
  - 3. Synchronous time and speed between subtile and audio
  - 4. Popping noises between audio segments
- Solutions
  - Algorithm diagram
  - Key Optimizations
- Conclusion

Introduction

When working with applications that involve video content and translation, it is often necessary to translate an original subtitle file (e.g., SRT format) into another language.
To enhance user experience, we can convert these translated subtitles into audio using TTS technology.
This tutorial will guide you through the process of converting subtitles to audio, addressing common challenges and providing solutions.

Workflow Overview

Convert from subtitle to audio is a job that need several steps to complete that why we will handle it asynchronously.
We choose lamba functions for saving cost and easy in implementation.
The workflow consist of the following steps:
1. Choose a subtitle file from current system: Assume our system already show list of subtitle files that user can choose from.
2. Choose voice settings: User can choose voice settings like male or female voice.
3. Request to convert subtitle to audio: After user choose subtitle file and voice settings we will send request to backend to start the conversion process.
4. Server request to s3 to get subtitle file: Because in real project we usually store files in s3, so our server need to get subtitle file url from s3 first.
5. Server request to lambda function to convert subtitle to audio: After get subtitle file url server will send request to lambda function to start convert subtitle to audio.
6. Lambda function process subtitle file: Lambda function will download subtitle file from s3, parse subtitle file to get text and timing information, then use google text to speech to convert text to audio, finally combine audio segments according to timing information and save the final audio file to s3.

Problems with workflow

1. Limited execution time of lambda functions

AWS Lambda functions have a maximum execution time limit (currently 15 minutes). If the subtitle file is large or the conversion process takes too long, the lambda function may time out before completing the task.

2. Limited resources within lambda functions

Lambda functions have limited CPU and memory resources. If the TTS engine requires more resources or inprogress the size of audio become to large, the conversion process may fail or produce error out of memory.

3. Synchronous time and speed between subtile and audio

Ensuring that the audio segments align perfectly with the timing information in the subtitle file can be challenging. Any discrepancies can lead to audio that is out of sync with the original video content.

4. Popping noises between audio segments

When combining multiple audio segments generated from subtitles, popping noises may occur at the boundaries between segments.

Solutions

This section will show you solutions for the problems mentioned above and successully in converting subtitle file more than 30 minutes to audio only in some minutes. Also implement it with at least resources, we only use default lambda function settings (128MB memory) and timeout is 15 minutes.

Algorithm diagram

Link algorithm diagram: Image

The flowchart above illustrates the complete subtitle-to-audio conversion algorithm with optimized memory management and streaming architecture. Here's how it works:

1. Initialization Phase

The process begins by downloading and parsing the SRT subtitle file from the provided URL
It pre-calculates the total PCM (Pulse Code Modulation) audio size based on subtitle duration and timing information
An S3 Multipart Upload is initialized to enable streaming upload without holding the entire file in memory
A WAV header is created and added to the part buffer, initializing tracking variables (part_number=1, content_id index=0, current_part=b"")

2. Batch Processing Loop

Instead of processing all subtitles at once, the algorithm processes them in batches of approximately 15 subtitles
For each batch, it retrieves the next set of subtitle entries to process
This batching approach prevents memory overflow by keeping only a small subset of subtitles in memory at any time

3. Audio Generation for Each Subtitle

For each subtitle in the current batch:
- Calculate speech speed: Determines the appropriate speaking rate to fit the subtitle text within its designated time window
- Generate audio using Google Cloud TTS: Converts the subtitle text to audio using the selected voice settings
- Apply fade effects: Adds 250ms fade-in and fade-out to prevent popping noises between audio segments
- Calculate and add silence padding: Adds appropriate silence gaps to ensure precise alignment with subtitle timing

4. Streaming Upload Mechanism

As audio segments are generated, PCM data is appended to the part buffer
When the buffer reaches 5MB or when processing the last batch, the current part is uploaded to S3 immediately
After each upload, the buffer is cleared and the part_number is incremented
This streaming approach ensures that Lambda memory usage remains constant (around 5-10MB) regardless of the total audio file size

5. Finalization Phase

Once all subtitle batches have been processed and all parts uploaded, the algorithm completes the S3 Multipart Upload
The final audio file is assembled from all uploaded parts and becomes available on S3
Error handling paths are included to manage upload failures or conversion issues (shown by the red error node)

Key Flow Control

The algorithm uses two main decision loops:
- "More batches to process?": Controls the outer loop for batch processing
- "More subtitles in batch?": Controls the inner loop for processing individual subtitles within a batch
"Buffer size >= 5MB OR last batch?": Triggers S3 part uploads at optimal intervals

Key Optimizations

Batch Processing: Subtitles are processed in batches (default: 15 subtitles per batch) instead of loading all at once. This prevents memory overflow in Lambda.
S3 Multipart Upload:
- Initialize multipart upload at the start
- Upload parts incrementally when buffer reaches 5MB
- Each part is uploaded immediately and buffer is cleared
- Complete multipart upload at the end
- This approach ensures Lambda never holds the entire audio file in memory
Streaming Architecture: Audio data flows directly from TTS → batch buffer → S3 parts, with minimal memory footprint at any given time.
Fade Effects: 250ms fade-in/out applied to each audio segment to eliminate popping noises between segments.
Memory Management: After each part upload, the buffer is reset, keeping memory usage constant regardless of total audio length.
Avoid FFmpeg and audio processing libraries:

We should avoid using FFmpeg (both the binary and Python wrappers like pydub, ffmpeg-python) in Lambda functions because they significantly increase deployment package size.
FFmpeg binaries are typically 50-100MB, and audio processing libraries add another 20-50MB, easily exceeding Lambda's package size limits.
Instead, we should work directly with WAV file format using Python's built-in struct module and pure Python code to manipulate raw PCM audio bytes.
This approach keeps the deployment package minimal (<15MB) while maintaining full control over audio processing operations like fade-in/fade-out, silence padding, and concatenation.

Conclusion

Thank you for following this tutorial on converting subtitles to audio using TTS technology.
I hope this information can help you to implement this feature in your own projects efficiently. You could use these ideas and use any AI tools for generating code to implement it.
This blog is written by my experience in real project that we need to save cost with lambda function, if you have any good ideas or suggestions please feel free to share with me!
You could find more on my blogs: Website

Understanding the Factory Method Pattern

longtk26 — Sat, 04 Jan 2025 15:18:34 +0000

Introduction

Hi everyone, I am writing this post to share my knowledge as I continue learning about design patterns. Today, I will present the Factory Method Pattern, which is a design pattern commonly used in real-world applications. If there are any mistakes in my post, please feel free to comment below, and I will gladly fix and update it.

Factory method pattern provides an interface for creating objects in a superclass, but allow subclasses to alter the type of objects that will be created.

Problem

Assume you have a bank application, and you’re building a feature for transferring money through various methods like bank transfer, paypal transfer,…

Before using the Factory Method pattern, let’s examine the scenario without it.

I will give an example implemented in Java.

Situation: Person1 sends money to Person2 using a transfer method (Bank Transfer or PayPal Transfer).

Folder structure:

problem/
├─ BankApp.java
├─ service/
│  ├─ PaypalTransferPayment.java
│  ├─ BankTransferPayment.java
├─ data/
│  ├─ Person.java

In the main application, create two persons with default amounts of money.

package problem;

import problem.data.Person;

public class BankApp {
    public static void main(String[] args) {
        Person person1 = new Person("John", 1000);
        Person person2 = new Person("Jane", 500);
    }
}

Create BankTransferPayment and PaypalTransferPayment classes.

package problem.service;

import problem.data.Person;

public class BankTransferPayment {
    public void processPayment(Person fromAccount, Person toAccount, float amount) {
        fromAccount.withdraw(amount);
        toAccount.deposit(amount);
        System.out.println("Bank transfer payment success.");
    }
}

package problem.service;

import problem.data.Person;

public class PaypalPayment {
    public void processPayment(Person fromAccount, Person toAccount, float amount) {
        fromAccount.withdraw(amount);
        toAccount.deposit(amount);
        System.out.println("Paypal transfer payment success.");
    }
}

Implement the logic in the main function.

package problem;

import problem.data.Person;
import problem.service.BankTransferPayment;
import problem.service.PaypalPayment;

public class BankApp {
    public static void main(String[] args) {
        Person person1 = new Person("John", 1000);
        Person person2 = new Person("Jane", 500);

        String paymentMethod = "BANK_TRANSFER";

        if (paymentMethod.equals("BANK_TRANSFER")) {
            BankTransferPayment bankTransferPayment = new BankTransferPayment();
            bankTransferPayment.processPayment(person1, person2, 100);

            System.out.println("===Method bank_transfer===");
            System.out.println(person1.getName() + " has " + person1.getAmount());
            System.out.println(person2.getName() + " has " + person2.getAmount());
        } else if (paymentMethod.equals("PAYPAL")) {
            PaypalPayment paypalPayment = new PaypalPayment();
            paypalPayment.processPayment(person1, person2, 100);

            System.out.println("===Method paypal===");
            System.out.println(person1.getName() + " has " + person1.getAmount());
            System.out.println(person2.getName() + " has " + person2.getAmount());
        }
    }
}

Problems with the current implementation:

Repetitive code: The processPayment method logic is repeated for every payment method.
Tightly coupled code: The application needs to create the payment method objects itself, making it hard to extend the application.
Scalability issues: If new payment methods are added, the source code becomes more complex and harder to maintain.

Solution

The solution to the above situation is to use factory method pattern. So, how do we apply it ?

In the example above:

Each if-else block calls the processPayment method, which leads to repetitive code.
Objects are created based on the payment type condition, making the code messy with excessive if-else statements.

To solve these issues, the Factory Method pattern will be implemented step by step.

Folder structure (solution):

solution/
├─ BankApp.java
├─ service/
│  ├─ payments/
│  │  ├─ Payment.java
│  │  ├─ PaymentFactory.java
│  │  ├─ BankTransferPayment.java
│  │  ├─ PaypalTransferPayment.java
├─ data/
│  ├─ Person.java

Step 1: Create Payment interface, declares common method processPayment

package solution.service.payments;

import solution.data.Person;

// Step 1: Create an interface for the payment
public interface Payment {
    void processPayment(Person fromAccount, Person toAccount,float amount);
}

Step 2: Create BankTransferPayment and PaypalTransferPayment classes implement Payment interface.

package solution.service.payments;

import solution.data.Person;

// Step 2: Create a class that implements the Payment interface
public class BankTransferPayment implements Payment {
    @Override
    public void processPayment(Person fromAccount, Person toAccount, float amount) {
        fromAccount.withdraw(amount);
        toAccount.deposit(amount);
        System.out.println("Bank transfer payment success.");
    }
}

package solution.service.payments;

import solution.data.Person;

public class PaypalPayment implements Payment{
    @Override
    public void processPayment(Person fromAccount, Person toAccount, float amount) {
        fromAccount.withdraw(amount);
        toAccount.deposit(amount);
        System.out.println("Paypal transfer payment success.");
    }
}

Step 3: Create PaymentFactory class. This class is responsible for creating objects based on payment type condition.

package solution.service.payments;

public class PaymentFactory {
    public Payment createPayment(String paymentType) {
        if (paymentType == null) {
            return null;
        }
        if (paymentType.equalsIgnoreCase("BANK_TRANSFER")) {
            return new BankTransferPayment();
        } else if (paymentType.equalsIgnoreCase("PAYPAL")) {
            return new PaypalPayment();
        }
        return null;
    }
}

Step 4: Use the Factory in the Main Application.

Modify the main function to use the Factory Method pattern.

package solution;

import solution.data.Person;
import solution.service.payments.Payment;
import solution.service.payments.PaymentFactory;

public class BankApp {
    public static void main(String[] args) {
        Person person1 = new Person("John", 1000);
        Person person2 = new Person("Jane", 500);

        String paymentMethod = "PAYPAL";

        Payment payment = new PaymentFactory().createPayment(paymentMethod);
        payment.processPayment(person1, person2, 100);
    }
}

Benefits of Using the Factory Method Pattern

The code is cleaner and more structured.
Repetitive calls to processPayment in multiple if-else blocks are eliminated.
Object creation is delegated to the factory, improving maintainability.

Bonus

To make the PaymentFactory class comply with the Open/Closed Principle (from SOLID principles), you can implement a dynamic registration mechanism using the Strategy Pattern.

Updated PaymentFactory.java:

package solution.service.payments;

import java.util.HashMap;
import java.util.Map;

public class PaymentFactory {
    private Map<String, Payment> paymentMaps;

    public PaymentFactory() {
        this.paymentMaps = new HashMap<>();
    }

    public Payment createPayment(String paymentType) {
        return paymentMaps.get(paymentType);
    }

    public void registerPayment(String paymentType, Payment payment) {
        paymentMaps.put(paymentType, payment);
    }

    public PaymentFactory initializePaymentMethods() {
        Payment bankTransferPayment = new BankTransferPayment();
        Payment paypalPayment = new PaypalPayment();

        this.registerPayment("BANK_TRANSFER", bankTransferPayment);
        this.registerPayment("PAYPAL", paypalPayment);

        return this;
    }
}

Using the Updated Factory in the Main Application.

package solution;

import solution.data.Person;
import solution.service.payments.Payment;
import solution.service.payments.PaymentFactory;

public class BankApp {
    public static void main(String[] args) {
        Person person1 = new Person("John", 1000);
        Person person2 = new Person("Jane", 500);

        String paymentMethod = "BANK_TRANSFER";

        Payment payment = new PaymentFactory()
                .initializePaymentMethods()
                .createPayment(paymentMethod);
        payment.processPayment(person1, person2, 100);
    }
}

By applying this approach, the code adheres to the Open/Closed Principle, enabling the addition of new payment methods without modifying the PaymentFactory logic.

I hope this post will be helpful to you.

References:

guru-design-patterns

DEV Community: longtk26

Subtitle to Audio Tutorial

Subtitle to Audio Tutorial

Table of Contents

Introduction

Workflow Overview

Problems with workflow

1. Limited execution time of lambda functions

2. Limited resources within lambda functions

3. Synchronous time and speed between subtile and audio

4. Popping noises between audio segments

Solutions

Algorithm diagram

Key Optimizations

Conclusion

Understanding the Factory Method Pattern

Introduction

Problem

Solution

Benefits of Using the Factory Method Pattern

Bonus

References: