Welcome back! In our previous lessons, we've explored basic transcribing techniques with Whisper, as well as calculating media duration using FFmpeg in Go. Today, we'll shift our focus to transcribing large files with Whisper and FFmpeg. Managing large audio or video files by splitting them into manageable pieces ensures that tasks like transcription can be performed efficiently and without errors. This lesson will empower you to handle these files smoothly, leveraging FFmpeg's capabilities from Go using the ffmpeg-go library.

Whisper has a file size limitation of 25 MB, which poses a challenge when attempting to transcribe large audio or video files. To work around this constraint, we need a method to divide these large files into smaller, manageable chunks that can be processed sequentially. Our strategy involves leveraging FFmpeg's capabilities to split the files into segments that fall within the permissible size limit. This will ensure compatibility with Whisper while maintaining the quality and integrity of the original content. By breaking down large files, we facilitate efficient transcription, allowing for smooth and accurate processing of each smaller segment.

Let's revisit how we retrieve the media's length using FFmpeg in Go with the ffmpeg-go library. In the previous lesson, we implemented the GetAudioDuration function, which uses the ffmpeg-go library to access ffprobe functionality directly from Go code:

This function calls ffmpeg_go.Probe, which internally runs ffprobe and returns the output as JSON. We then parse the JSON to extract the duration of the media file. This approach allows us to programmatically determine the length of any audio or video file, which is essential for calculating how to split the file into appropriately sized chunks.

To split a large media file into smaller chunks, we use the SplitIntoChunk function from internal/transcriber/transcriber.go. This function uses FFmpeg via the ffmpeg-go library to extract a specific chunk from the media file, given a start time and duration.

Code Explanation:

1. Parameters:

   • filePath: Path to the original media file.
   • startTime: The start time (in seconds) for the chunk.
   • duration: The duration (in seconds) of the chunk.
   • chunkNumber: The index of the chunk (used for naming).

2. Output Path:

   • The chunk is saved in the resources directory with a name like chunk_1.mp3.

To split a file into multiple chunks, you can use GetAudioDuration to determine the total duration, then call SplitIntoChunk in a loop, specifying the start time and duration for each chunk. For example, to split a file into 10-second chunks:

This will create chunk files like chunk_1.mp3, chunk_2.mp3, etc., in the resources directory.

To test the splitting functionality, you can call the SplitIntoChunk function with a sample media file and a desired chunk size. For example:

After running the code, you should see output similar to:

You can then check the resources directory for the new chunk file.

You have learned how to split large media files into smaller chunks using FFmpeg in Go, leveraging the ffmpeg-go library and the SplitIntoChunk function. This approach allows you to process large files efficiently and prepare them for transcription with Whisper, staying within file size limits and ensuring smooth, error-free operation.