Welcome back! In our previous lessons, we've explored using basic transcribing techniques with OpenAI's Whisper API, as well as calculating the media duration using FFmpeg. Today, we'll shift our focus to transcribing large files with OpenAI 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.

OpenAI 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 OpenAI 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 consider Python code to achieve this, ensuring all steps are easily comprehensible. First, let's revisit how we retrieve the media's length using FFmpeg:

import math
import os
import subprocess
import tempfile

def get_audio_duration(file_path):
    """Get the duration of an audio file using ffprobe"""
    cmd = [
        'ffprobe', 
        '-v', 'quiet',
        '-show_entries', 'format=duration',
        '-of', 'default=noprint_wrappers=1:nokey=1',
        file_path
    ]
    try:
        output = subprocess.check_output(cmd)
        return float(output)
    except:
        return None

This section of the code employs ffprobe to determine an audio file's duration. ffprobe is a component of FFmpeg that fetches file data without altering it. The command is carefully structured to extract only the duration, allowing us to calculate how to split the file accordingly.

Now, let's implement one more helper function. Splitting a media file into chunks is a time-consuming process, and FFmpeg will produce its logs as a stream - they will iteratively appear as it keeps processing the file. In order for us to process that efficiently, we should implement a way to stream these logs to the console in Python:

def run_command_with_output(cmd, desc=None):
    """Run a command and stream its output in real-time"""
    if desc:
        print(f"\n{desc}")
    
    process = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        universal_newlines=True
    )
    
    for line in iter(process.stdout.readline, ''):
        print(line, end='')
    
    process.stdout.close()
    return_code = process.wait()
    
    if return_code != 0:
        raise subprocess.CalledProcessError(return_code, cmd)

This helper function allows us to run commands and stream outputs in real time. By setting up a subprocess, it captures output line-by-line, ensuring you keep track of the progress during long operations, a critical feature when managing large files.

The process of splitting media files into smaller chunks involves key FFmpeg commands that work together to extract segments without re-encoding. Let's break down the code to see how it operates:

def split_media(file_path, chunk_size_mb=20):
    """Split media file into chunks smaller than the API limit"""
    print("\nSplitting media into chunks...")
    
    duration = get_audio_duration(file_path)
    if not duration:
        raise Exception("Could not determine audio duration")
    
    file_size = os.path.getsize(file_path)
    chunk_duration = duration * (chunk_size_mb * 1024 * 1024) / file_size
    num_chunks = math.ceil(duration / chunk_duration)
    
    chunks = []
    for i in range(num_chunks):
        start_time = i * chunk_duration
        temp_file = tempfile.NamedTemporaryFile(
            delete=False,
            suffix=os.path.splitext(file_path)[1]
        )
        
        cmd = [
            'ffmpeg',
            '-i', file_path,    # Specify the input file to process
            '-ss', str(start_time),  # Set the start time of the chunk
            '-t', str(chunk_duration),  # Define the chunk's duration
            '-c', 'copy',   # Copy streams without re-encoding for efficiency
            '-y',   # Overwrite output files without confirmation
            temp_file.name
        ]
        
        run_command_with_output(
            cmd, 
            f"Extracting chunk {i+1}/{num_chunks}"
        )
        chunks.append(temp_file.name)
    print(f"Split media into {len(chunks)} chunk(s): {chunks}")
    return chunks

Code Explanation:

1. Initialize Variables:

   • We first determine the duration of the media file using the helper get_audio_duration function.
   • The file_size is retrieved to calculate the proper chunk duration that fits within the specified chunk_size_mb limit (which is by default 20Mb).

2. Calculate Chunks:

   • chunk_duration uses the ratio of chunk_size_mb to file_size multiplied by the duration to find how long each chunk should be.
   • num_chunks calculates the total number of chunks required by dividing the full duration by chunk_duration and rounding up.

3. Create Each Chunk:

   • A loop iterates over each chunk, calculating the start_time for each segment.
   • A temporary file is created for storing the chunk. This file will mimic the original file's extension for compatibility.

4. FFmpeg Command:

   • -i specifies the input file.
   • -ss sets the start time for each chunk.
   • -t sets the duration for each chunk.
   • -c copy ensures content is copied directly without re-encoding, preserving quality and improving efficiency.
   • -y automatically overwrites existing output files without user confirmation.

5. Run Command and Store Chunks:

   • run_command_with_output executes the FFmpeg command, streaming progress to keep the user informed.
   • Each generated temporary file is appended to the chunks list, which is later returned for further processing.

This approach systematically breaks down large files into smaller, manageable pieces using FFmpeg's powerful media handling capabilities.

Running the code (e.g., split_media('resources/sample_video.mp4', 1)) will print something like this:

Splitting media into chunks...

Extracting chunk 1/2
<ffmpeg output for chunk 1>


Extracting chunk 2/2
<ffmpeg output for chunk 2>

Split media into 2 chunk(s): ['/tmp/tmprgsjob1j.mp4', '/tmp/tmpr2iqj_ll.mp4']

The sample_video.mp4 video file size is around 2Mb, so splitting it into chunk_size_mb produces 2 chunks of 1 Mb, both of which are properly extracted with FFmpeg and saved as separate temporary files.

Congratulations on mastering the process of splitting large media files using FFmpeg! In this lesson, you've learned how to leverage FFmpeg's capabilities to efficiently break down large files into smaller, manageable chunks. By understanding the intricacies of file handling, you can now enhance file operations, reduce memory overhead, and enable parallel processing for improved performance, all while maintaining content quality. You’re now well-equipped to tackle large-scale multimedia tasks with confidence and precision!