How to compress video to target size by Python?

Question

I am uploading text and videos to a site by Python program. This site says they only receive video files of up to 50 MB in size. Otherwise, they will reject the video and other associated information.

To ensure I can send video continuously, I want to compress it to target size (e.g. 50 MB) before sending. Because no loss of quality is impossible, it is ok to have moderate clarity loss in video or audio.

Is there any elegant way in Python for this purpose? Thanks!

Answer 1

Compress video files by Python and FFmpeg

Tools

FFmpeg is a powerful tool for video editing. And there is a great Python binding named ffmpeg-python (API Reference) for this. Firstly, pip install ffmpeg-python and install FFmpeg.

Steps

Probe the configuration of video by function ffmpeg.probe() to get duration, audio & video bit rate and so on. And calculate the bit rate of the target file based on what we have. Then, construct commands by ffmpeg.input() and ffmpeg.output(). Finally, run it.

Codes

Following is the example code. Change the compression algo for your situation if you want. For easy follow-up, I hided the code of boundary condition. The code I am using is in GitHub Gist. Any bug report is welcomed!

import os, ffmpeg
def compress_video(video_full_path, output_file_name, target_size):
    # Reference: https://en.wikipedia.org/wiki/Bit_rate#Encoding_bit_rate
    min_audio_bitrate = 32000
    max_audio_bitrate = 256000

    probe = ffmpeg.probe(video_full_path)
    # Video duration, in s.
    duration = float(probe['format']['duration'])
    # Audio bitrate, in bps.
    audio_bitrate = float(next((s for s in probe['streams'] if s['codec_type'] == 'audio'), None)['bit_rate'])
    # Target total bitrate, in bps.
    target_total_bitrate = (target_size * 1024 * 8) / (1.073741824 * duration)

    # Target audio bitrate, in bps
    if 10 * audio_bitrate > target_total_bitrate:
        audio_bitrate = target_total_bitrate / 10
        if audio_bitrate < min_audio_bitrate < target_total_bitrate:
            audio_bitrate = min_audio_bitrate
        elif audio_bitrate > max_audio_bitrate:
            audio_bitrate = max_audio_bitrate
    # Target video bitrate, in bps.
    video_bitrate = target_total_bitrate - audio_bitrate

    i = ffmpeg.input(video_full_path)
    ffmpeg.output(i, os.devnull,
                  **{'c:v': 'libx264', 'b:v': video_bitrate, 'pass': 1, 'f': 'mp4'}
                  ).overwrite_output().run()
    ffmpeg.output(i, output_file_name,
                  **{'c:v': 'libx264', 'b:v': video_bitrate, 'pass': 2, 'c:a': 'aac', 'b:a': audio_bitrate}
                  ).overwrite_output().run()

# Compress input.mp4 to 50MB and save as output.mp4
compress_video('input.mp4', 'output.mp4', 50 * 1000)

Notes

1. Don't waste your time! Judge the file size before compressing.

2. You can disable two-pass function by only keeping second ffmpeg.output() without parameter 'pass': 2.

3. If video bit rate < 1000, it will throw exception Bitrate is extremely low.

4. The biggest min file size I recommend is:

# Best min size, in kB.
best_min_size = (32000 + 100000) * (1.073741824 * duration) / (8 * 1024)

5. If you specify a extremely small target file size, the size of generated file maybe exceed it. For most time, this will not happen.

Answer 2

I have used MoviePy in the past with good results. Another option (not the safest) might be to run FFMpeg as an external process to compress or resize the media file.

Answer 3

Split the video into segments, compress each segment, and then merge the compressed segments back into a single video file. This will reduce the execution time into half. Here's an explanation of the code:

import time
import os
from moviepy.editor import VideoFileClip, concatenate_videoclips
from threading import Thread

input_file = r'D:\d_test\video_1.mp4'
output_dir = r'D:\d_test\output'
os.makedirs(output_dir, exist_ok=True)

start_time = time.time()
split_duration = 60
video = VideoFileClip(input_file)
video_duration = video.duration
num_splits = int(video_duration / split_duration) + 1
def process_video_segment(start_time, end_time, output_file):
    segment = video.subclip(start_time, end_time)
    compressed_segment = segment.resize(width=640, height=480).fx('codecname', 'libx265', bitrate='500k')
    compressed_segment.write_videofile(output_file, codec='libx264')

threads = []
for i in range(num_splits):
    split_start_time = i * split_duration
    split_end_time = min((i + 1) * split_duration, video_duration)
    output_file = os.path.join(output_dir, f'compressed_segment{i+1}.mp4')
    process_thread = Thread(target=process_video_segment, args=(split_start_time, split_end_time, output_file))
    process_thread.start()
    threads.append(process_thread)

for thread in threads:
    thread.join()

print("Video segments processed successfully.")
compressed_files = [os.path.join(output_dir, f'compressed_segment{i+1}.mp4') for i in range(num_splits)]

merged_file = os.path.join(output_dir, 'merged_video.mp4')
clips = [VideoFileClip(file) for file in compressed_files]
final_clip = concatenate_videoclips(clips)
final_clip.write_videofile(merged_file, codec='libx264')

print("Video merging completed successfully.")

end_time = time.time()
execution_time = end_time - start_time
print(f"Execution time: {execution_time} seconds")