Automate Video Processing Tasks with Python and FFmpeg#

1
import subprocess
2
import sys # Import sys to check for ffmpeg availability
3

4
# Example: Check FFmpeg version
5
try:
6
    # The command and its arguments as a list
7
    command = ["ffmpeg", "-version"]
8

9
    # Execute the command
10
    result = subprocess.run(command, capture_output=True, text=True, check=True)
11

12
    # Print the output
13
    print("FFmpeg Version Info:")
14
    print(result.stdout)
15

16
except FileNotFoundError:
17
    print("Error: FFmpeg command not found. Ensure FFmpeg is installed and in the system's PATH.")
18
    sys.exit(1) # Exit the script if FFmpeg is not found
19
except subprocess.CalledProcessError as e:
20
    print(f"Error executing FFmpeg command: {e}")
21
    print(f"Stderr: {e.stderr}")
22
    sys.exit(1)
23
except Exception as e:
24
    print(f"An unexpected error occurred: {e}")
25
    sys.exit(1)

1
# Basic structure for a conversion command
2
ffmpeg_command = [
3
    "ffmpeg",
4
    "-i", "input_video.mp4", # Input file
5
    "-c:v", "libx264",        # Video codec (H.264)
6
    "-c:a", "aac",            # Audio codec (AAC)
7
    "output_video.mp4"        # Output file
8
]
9

10
# You can add more options based on requirements
11
# ffmpeg_command.extend(["-vf", "scale=640:480"]) # Add a video filter for resizing
12

13
# Then execute:
14
# try:
15
#     subprocess.run(ffmpeg_command, check=True)
16
# except subprocess.CalledProcessError as e:
17
#     print(f"FFmpeg processing failed: {e.stderr}")

1
import subprocess
2
import os # Import os for path manipulation
3

4
def transcode_video(input_path, output_path, video_codec="libx264", audio_codec="aac"):
5
    """Transcodes a video file to a new format/codec."""
6
    command = [
7
        "ffmpeg",
8
        "-i", input_path,
9
        "-c:v", video_codec,
10
        "-c:a", audio_codec,
11
        "-y", # Overwrite output file without asking
12
        output_path
13
    ]
14

15
    print(f"Processing: {input_path} -> {output_path}")
16
    print(f"Command: {' '.join(command)}")
17

18
    try:
19
        # Show FFmpeg progress output in real-time (optional, more complex)
20
        # Or just run and check for errors:
21
        result = subprocess.run(command, check=True, capture_output=True, text=True)
22
        print(f"Successfully transcoded {input_path}")
23
        # print("FFmpeg Output:\n", result.stdout) # Uncomment to see successful output
24
        # print("FFmpeg Errors (if any):\n", result.stderr) # FFmpeg progress is often in stderr
25

26
    except FileNotFoundError:
27
        print("Error: FFmpeg not found. Ensure it's installed and in PATH.")
28
    except subprocess.CalledProcessError as e:
29
        print(f"Error during transcoding {input_path}:")
30
        print(f"Command failed: {' '.join(e.cmd)}")
31
        print(f"Return code: {e.returncode}")
32
        print(f"Stderr:\n{e.stderr}")
33
    except Exception as e:
34
        print(f"An unexpected error occurred for {input_path}: {e}")
35

36
# Example usage:
37
# Assuming 'input.mkv' exists in the same directory
38
# input_file = "input.mkv"
39
# output_file = "output_transcoded.mp4"
40
# if os.path.exists(input_file):
41
#     transcode_video(input_file, output_file)
42
# else:
43
#     print(f"Input file not found: {input_file}")
44

45
# Example for batch processing (loop through files in a directory)
46
# input_directory = "videos_to_process"
47
# output_directory = "processed_videos"
48
# if not os.path.exists(output_directory):
49
#     os.makedirs(output_directory)
50

51
# if os.path.exists(input_directory):
52
#     for filename in os.listdir(input_directory):
53
#         if filename.endswith(".mkv"): # Process only MKV files
54
#             input_filepath = os.path.join(input_directory, filename)
55
#             # Change extension to mp4 for output
56
#             output_filename = os.path.splitext(filename)[0] + ".mp4"
57
#             output_filepath = os.path.join(output_directory, output_filename)
58
#
59
#             transcode_video(input_filepath, output_filepath)
60
# else:
61
#     print(f"Input directory not found: {input_directory}")

1
import subprocess
2
import os
3

4
def trim_video(input_path, output_path, start_time, duration):
5
    """Trims a video file from start_time for duration (HH:MM:SS or seconds)."""
6
    # Using -ss before -i for potentially faster seeking with some formats,
7
    # but duration might be approximate depending on keyframes with -c copy.
8
    # For accuracy with -c copy, -ss after -i might be needed depending on format.
9
    # For guaranteed accuracy, remove -c copy and allow re-encoding.
10
    command = [
11
        "ffmpeg",
12
        "-ss", str(start_time), # Start time
13
        "-i", input_path,
14
        "-t", str(duration),    # Duration
15
        "-c", "copy",           # Copy streams without re-encoding
16
        "-y",                   # Overwrite
17
        output_path
18
    ]
19

20
    print(f"Trimming: {input_path} from {start_time} for {duration}s -> {output_path}")
21

22
    try:
23
        subprocess.run(command, check=True, capture_output=True, text=True)
24
        print(f"Successfully trimmed {input_path}")
25
    except FileNotFoundError:
26
        print("Error: FFmpeg not found.")
27
    except subprocess.CalledProcessError as e:
28
        print(f"Error during trimming {input_path}:\n{e.stderr}")
29
    except Exception as e:
30
        print(f"An unexpected error occurred for {input_path}: {e}")
31

32
# Example usage:
33
# input_file = "input.mp4"
34
# output_file = "output_clip.mp4"
35
# start = "00:00:05" # Or 5 (seconds)
36
# dur = "00:00:10" # Or 10 (seconds)
37
# if os.path.exists(input_file):
38
#     trim_video(input_file, output_file, start, dur)
39
# else:
40
#     print(f"Input file not found: {input_file}")

1
import subprocess
2
import os
3

4
def extract_audio(input_path, output_path, audio_codec="libmp3lame", audio_bitrate="192k"):
5
    """Extracts audio from a video file."""
6
    command = [
7
        "ffmpeg",
8
        "-i", input_path,
9
        "-vn",                  # No video
10
        "-acodec", audio_codec,
11
        "-ab", audio_bitrate,
12
        "-y",                   # Overwrite
13
        output_path
14
    ]
15

16
    print(f"Extracting audio: {input_path} -> {output_path}")
17

18
    try:
19
        subprocess.run(command, check=True, capture_output=True, text=True)
20
        print(f"Successfully extracted audio from {input_path}")
21
    except FileNotFoundError:
22
        print("Error: FFmpeg not found.")
23
    except subprocess.CalledProcessError as e:
24
        print(f"Error during audio extraction {input_path}:\n{e.stderr}")
25
    except Exception as e:
26
        print(f"An unexpected error occurred for {input_path}: {e}")
27

28
# Example usage:
29
# input_file = "input.mp4"
30
# output_file = "output_audio.mp3"
31
# if os.path.exists(input_file):
32
#     extract_audio(input_file, output_file)
33
# else:
34
#     print(f"Input file not found: {input_file}")

1
import subprocess
2
import os
3

4
def resize_video(input_path, output_path, width, height=-1):
5
    """Resizes a video file using the scale filter."""
6
    # Use -1 for width or height to maintain aspect ratio
7
    scale_filter = f"scale={width}:{height}"
8

9
    command = [
10
        "ffmpeg",
11
        "-i", input_path,
12
        "-vf", scale_filter,
13
        "-c:a", "copy", # Copy audio to avoid re-encoding it
14
        "-y",           # Overwrite
15
        output_path
16
    ]
17

18
    print(f"Resizing: {input_path} to {width}x{height} -> {output_path}")
19

20
    try:
21
        subprocess.run(command, check=True, capture_output=True, text=True)
22
        print(f"Successfully resized {input_path}")
23
    except FileNotFoundError:
24
        print("Error: FFmpeg not found.")
25
    except subprocess.CalledProcessError as e:
26
        print(f"Error during resizing {input_path}:\n{e.stderr}")
27
    except Exception as e:
28
        print(f"An unexpected error occurred for {input_path}: {e}")
29

30
# Example usage:
31
# input_file = "input.mp4"
32
# output_file = "output_resized.mp4"
33
# new_width = 640
34
# if os.path.exists(input_file):
35
#     resize_video(input_file, output_file, new_width)
36
# else:
37
#     print(f"Input file not found: {input_file}")

1
import subprocess
2
import os
3

4
def add_watermark(input_path, watermark_path, output_path, position="W-w-10:H-h-10"):
5
    """Adds a watermark image to a video file."""
6
    # position examples: '10:10' (top-left), 'W-w-10:10' (top-right), '10:H-h-10' (bottom-left), 'W-w-10:H-h-10' (bottom-right)
7

8
    command = [
9
        "ffmpeg",
10
        "-i", input_path,
11
        "-i", watermark_path,
12
        "-filter_complex", f"[0:v][1:v]overlay={position}",
13
        "-c:a", "copy", # Copy audio
14
        "-y",           # Overwrite
15
        output_path
16
    ]
17

18
    print(f"Adding watermark: {input_path} + {watermark_path} -> {output_path}")
19

20
    try:
21
        subprocess.run(command, check=True, capture_output=True, text=True)
22
        print(f"Successfully added watermark to {input_path}")
23
    except FileNotFoundError:
24
        print("Error: FFmpeg or watermark file not found.")
25
    except subprocess.CalledProcessError as e:
26
        print(f"Error during watermarking {input_path}:\n{e.stderr}")
27
    except Exception as e:
28
        print(f"An unexpected error occurred for {input_path}: {e}")
29

30
# Example usage:
31
# input_file = "input.mp4"
32
# watermark_file = "watermark.png"
33
# output_file = "output_watermarked.mp4"
34
# if os.path.exists(input_file) and os.path.exists(watermark_file):
35
#     add_watermark(input_file, watermark_file, output_file)
36
# else:
37
#     print(f"Input video or watermark file not found.")