Extracting and Modifying Information in MoviePy

March 13, 2025

When working with video clips, metadata plays a crucial role in understanding the characteristics of your files. Metadata includes vital information such as the video’s duration, frame rate, resolution, codec, and more. Whether you're preparing a video for editing, checking compatibility with other media, or automating tasks, understanding how to handle metadata is essential.

In this blog post, we’ll walk you through how to extract, read, and modify metadata from video clips using MoviePy. This Python-based library makes it easy to access and manipulate this information to help improve your video processing workflow.


What is Video Metadata?

Video metadata refers to the underlying data that describes the characteristics of a video file. It contains information about:

  • Frame rate: How many frames per second (fps) the video runs at.
  • Resolution: The width and height of the video.
  • Duration: The total length of the video.
  • Codec: The format used to compress and store the video.
  • Audio data: Information about the audio channels, sample rate, etc.

This metadata is often embedded in the video file, and MoviePy allows you to access it with ease.

 

Extracting Video Metadata

MoviePy offers simple methods for extracting metadata from video clips. Here's how you can extract basic information like duration, resolution, and frame rate.

 

Step 1: Load the Video Clip

To access a video’s metadata, first load the video clip into MoviePy using the VideoFileClip function.

from moviepy.editor import VideoFileClip

# Load the video clip
video = VideoFileClip("example_video.mp4")

Once the video clip is loaded, you can access its metadata.

 

Step 2: Extract Metadata Information

Now that the video is loaded, you can extract key metadata information such as the frame rate, duration, resolution, and audio information.

# Get the duration of the video (in seconds)
duration = video.duration
print(f"Duration: {duration} seconds")

# Get the frame rate of the video (frames per second)
frame_rate = video.fps
print(f"Frame Rate: {frame_rate} fps")

# Get the resolution of the video (width, height)
resolution = video.size
print(f"Resolution: {resolution[0]}x{resolution[1]} pixels")

# Get the video’s audio (if it exists)
audio = video.audio
if audio:
    print("Audio present")
    # Get the audio duration
    audio_duration = audio.duration
    print(f"Audio Duration: {audio_duration} seconds")
else:
    print("No audio in video")

In this example:

  • video.duration provides the total length of the video in seconds.
  • video.fps gives you the frame rate (frames per second) of the video.
  • video.size returns the resolution of the video as a tuple (width, height).
  • video.audio returns the audio part of the video if present, and you can extract the audio’s duration.

 

 

Modifying Video Metadata

While MoviePy makes it easy to extract metadata, it also allows you to modify certain aspects of the video, such as the frame rate and resolution. Below, we’ll explore how to modify the video’s resolution and frame rate, and then save the changes to a new file.

 

Step 3: Modify Video Resolution

If you want to resize a video to a new resolution, you can do so using the resize() method. For example, if you want to change the resolution of the video to a specific height or width:

# Resize the video to a specific height, maintaining the aspect ratio
new_video = video.resize(height=480)

# Or, resize the video to a specific width
# new_video = video.resize(width=640)

# Export the resized video
new_video.write_videofile("resized_video.mp4", codec="libx264")

In this example, the video is resized while maintaining the aspect ratio by specifying a new height (height=480). You could also specify the width or scale the video by a percentage (e.g., video.resize(0.5) to scale down by 50%).

 

Step 4: Modify Frame Rate

You can also change the frame rate of a video, which is useful if you're preparing the video for a specific platform or need to adjust the video’s playback speed.

# Change the frame rate to 30 fps
new_frame_rate_video = video.set_fps(30)

# Export the video with the new frame rate
new_frame_rate_video.write_videofile("frame_rate_changed_video.mp4", codec="libx264")

This code sets the video’s frame rate to 30 frames per second (set_fps(30)). Be cautious when modifying the frame rate as this can affect the video’s smoothness, especially when converting from high to low frame rates.

 

 

Combining Video Metadata with Other Clips

MoviePy also allows you to merge video clips and modify their metadata during the composition process. For example, you can overlay images or combine multiple video clips while keeping track of their metadata.

 

Step 5: Overlay a Clip on Another and Maintain Metadata

Here’s how to overlay a clip on top of another while keeping the original video’s metadata:

from moviepy.editor import VideoFileClip, CompositeVideoClip, ImageClip

# Load two video clips and an image to overlay
background = VideoFileClip("background_video.mp4")
overlay = VideoFileClip("overlay_video.mp4").resize(height=200)
logo = ImageClip("logo.png").resize(height=100).set_duration(background.duration)

# Position the overlay and logo
overlay = overlay.set_position(("right", "top"))
logo = logo.set_position(("left", "bottom"))

# Combine the clips
final_video = CompositeVideoClip([background, overlay, logo])

# Write the final output
final_video.write_videofile("final_composite_video.mp4", codec="libx264")

In this example:

  • The CompositeVideoClip is used to overlay the overlay_video and the logo on top of the background_video.
  • All clips maintain their original metadata, including the duration and frame rate.

 

 

Extracting Additional Metadata (Using FFmpeg)

While MoviePy provides basic methods for extracting common metadata, sometimes you may need more detailed information, such as the codec or bit rate. For this, MoviePy relies on FFmpeg (a powerful multimedia framework), which can extract a wider variety of metadata.

Here’s how you can use FFmpeg directly to extract more detailed metadata:

import subprocess

# Extract metadata using FFmpeg
def get_metadata(video_path):
    cmd = ["ffmpeg", "-i", video_path]
    result = subprocess.run(cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
    metadata = result.stderr.decode()
    return metadata

# Get detailed metadata from a video file
metadata = get_metadata("example_video.mp4")
print(metadata)

This approach uses FFmpeg’s command-line interface to retrieve a variety of metadata about the video, including the codec, bit rate, and more. The information is captured by calling the ffmpeg command and parsing its output.

 

 

Conclusion

Working with video metadata in MoviePy is straightforward and can be extremely useful when preparing your videos for further processing or editing. Whether you’re extracting basic details like duration, resolution, and frame rate, or making modifications such as resizing and changing frame rates, MoviePy provides an easy-to-use interface for handling video metadata.

By understanding how to access and modify metadata, you can automate video processing tasks, optimize videos for various platforms, and ensure that your media files meet the necessary specifications. So, the next time you need to adjust the metadata of your videos, MoviePy has you covered with just a few lines of Python code!


Post a Comment

0 Comments