Merge Video Files with Python

Capturing memories or creating content often involves using devices like camcorders or smartphones. However, when recording long videos, users frequently encounter an issue where the device splits the recording into smaller files for better management and to overcome file size limitations on SD cards. This segmentation, while useful for hardware, creates a challenge during post-processing, especially when the objective is to compile these segments into a single, continuous video. Addressing this challenge, the Python script discussed in this article offers a streamlined solution by leveraging the capabilities of FFMPEG, a powerful multimedia processing tool. The script was developed to automate the merging process, providing users with a simple method to consolidate their video files without compromising quality.

Why FFMPEG?

FFMPEG is a free, open-source software project consisting of a vast library of tools and programs for handling video, audio, and other multimedia files and streams. At its core, FFMPEG is capable of decoding, encoding, transcoding, muxing, demuxing, streaming, filtering, and playing virtually any type of multimedia file. It is renowned for its versatility, efficiency, and high-quality output, making it the preferred choice for professionals and hobbyists alike in the multimedia domain.

Installing FFMPEG

Before utilizing the Python script, it is imperative to have FFMPEG installed on your system. Installation procedures vary depending on the operating system:

For Windows Users

1. Download FFMPEG: Visit the official FFMPEG website (https://ffmpeg.org/download.html) and download the latest version of FFMPEG for Windows.
2. Extract the Files: Once the download is complete, extract the ZIP file to a location of your choice, such as C:\FFMPEG.
3. Add FFMPEG to the System Path:
   • Right-click on ‘This PC’ or ‘My Computer’ and select ‘Properties’.
   • Navigate to ‘Advanced system settings’ and click on ‘Environment Variables’.
   • Under ‘System Variables’, find and select the ‘Path’ variable, then click ‘Edit’.
   • Click ‘New’ and add the path to the FFMPEG bin directory, e.g., C:\FFMPEG\bin.
   • Click ‘OK’ to close all dialogues.

For macOS Users

FFMPEG can be installed using Homebrew, a package manager for macOS, by executing the following command in the terminal:

brew install ffmpeg

For Linux Users

Most Linux distributions include FFMPEG in their package repositories. Open the Terminal and use the package manager to install FFMPEG. For example, on Ubuntu or Debian-based systems, type:

sudo apt update
sudo apt install ffmpeg

After installation, verify that FFMPEG is correctly installed by running ffmpeg -version in your terminal or command prompt. Successful installation will display the version and configuration details of FFMPEG.

The Script

The provided Python script automates the process of merging video files, specifically those in the MP4 format, residing within a single directory. It is designed to ensure a seamless integration of video segments into a single file without transcoding, preserving the original quality of the videos.

#!/usr/bin/python3
import os
import subprocess


def merge_mp4_files(directory, output_file):
    # Ensure the directory exists
    if not os.path.isdir(directory):
        print(f"The directory {directory} does not exist.")
        return

    # Find and sort all MP4 files in the directory
    mp4_files = sorted([file for file in os.listdir(directory) if file.endswith('.mp4')])

    if not mp4_files:
        print("No MP4 files found in the directory.")
        return

    # Create a temporary file list for ffmpeg
    list_path = os.path.join(directory, 'file_list.txt')
    with open(list_path, 'w') as list_file:
        for mp4_file in mp4_files:
            list_file.write(f"file '{mp4_file}'\n")

    # Merge the MP4 files
    try:
        subprocess.run(['ffmpeg', '-f', 'concat', '-safe', '0', '-i', list_path, '-c', 'copy', output_file], check=True)
        print(f"Merge complete. Output file: {os.path.join(directory, output_file)}")
    except subprocess.CalledProcessError as e:
        print(f"An error occurred during merging: {e}")

    # Clean up the temporary file list
    os.remove(list_path)


if __name__ == "__main__":
    input_directory = 'video_files'
    output_file = "merged.mp4"
    merge_mp4_files(input_directory, output_file)

Here’s a breakdown of how the script operates:

1. Directory Validation: Initially, the script checks if the specified directory exists and contains MP4 files. This validation prevents errors related to file not found or incorrect directory paths.
2. File Aggregation: It then proceeds to aggregate all MP4 files within the directory, sorting them alphabetically to maintain the order. This step ensures that the video segments are merged in the correct sequence.
3. Temporary File List Creation: The script creates a temporary text file (file_list.txt) listing all video files to be merged. This list serves as an input for FFMPEG, detailing the files to concatenate.
4. Video Merging: Utilizing FFMPEG, the script executes a command to merge the listed MP4 files into a single output file. The -c copy parameter ensures that the merge process does not re-encode the videos, thus preserving the original quality.
5. Cleanup: Upon successful merging, the script removes the temporary file list, keeping the directory tidy.

How to Use the Script

To use the script, follow these steps:

1. Ensure Python (version 3 or above) and FFMPEG are installed on your system.
2. Save the script to a location on your computer.
3. Modify the input_directory variable within the script to point to the directory containing your MP4 video files. The output_file variable can also be adjusted to specify the desired name for the merged video file.
4. Open a terminal or command prompt, navigate to the directory containing the script, and execute it by running:

   python3 script_name.py

   Replace script_name.py with the actual name of your Python script file.

5. The script will automatically merge the video files and save the output in the specified directory.

Conclusion

This Python script offers an efficient and user-friendly solution for merging video files that have been split during recording. By leveraging the powerful capabilities of FFMPEG, it ensures that the quality of the original videos is preserved in the final merged file. Whether you are compiling home videos, creating content for social media, or working on a professional multimedia project, this script simplifies the post-processing workflow, allowing you to focus on the creative aspects of your work. With the instructions provided, installing FFMPEG and executing the script becomes a straightforward process, making video merging accessible to anyone with basic computer skills.