How to Trim a Video Using FFmpeg

FFmpeg is a powerful, open-source command-line tool for processing video and audio files. One of the most common video editing tasks is trimming - cutting out a specific segment of a video. This guide will explain you how to use FFmpeg to quickly trim videos on your local machine and then show you how to automate the process for many videos.

Let's start!

Understanding FFmpeg Basics

Before we dive into trimming, let's briefly cover what FFmpeg is and why it's so useful for programmatic video creation.

FFmpeg is a comprehensive solution for recording, converting, and streaming audio and video. It is widely used in backend services and video processing pipelines, making it an excellent tool for your video creation needs.

Installing FFmpeg

Before you begin, ensure FFmpeg is installed on your system. You can install it on your system:

On macOS:

brew install ffmpeg

On Ubuntu/Debian:

sudo apt update
sudo apt install ffmpeg

On Windows:

Download the latest build from the official website and follow the installation instructions.

Basic Concepts

Let's define some basic terms before starting:

Encoding: Encoding is the process of converting raw media data (such as video or audio) into a digital format using a specific codec. This process enables efficient storage, transmission, and playback across different devices by transforming the media into a compressed, standardized form.

Compression: Compression refers to the techniques used to reduce the size of a media file by eliminating redundant or unnecessary data. There are two main types:

• Lossless Compression: Reduces file size without any loss of quality, preserving all original data.
• Lossy Compression: Reduces file size by permanently removing some data, which may result in a slight loss of quality.

This process is essential for efficient storage and faster streaming or transmission.

Keyframe: A keyframe is a complete, standalone frame within a video that is encoded without reference to other frames. In video compression, keyframes act as reference points for subsequent frames that only store the differences from these keyframes (interframe compression). This approach significantly reduces file size while enabling effective seeking and editing in video playback.

Basic Video Trimming with FFmpeg

Trimming a video means extracting a segment defined by a start time and an end time or duration.

The simplest way to trim a video with FFmpeg is to use the -ss and -t flags. The basic syntax for trimming a video with FFmpeg is:

ffmpeg -i input.mp4 -ss [start_time] -t [duration] -c copy output.mp4

For example, to extract a clip from 1 minute and 30 seconds to 2 minutes:

ffmpeg -i input.mp4 -ss 00:01:30 -t 00:00:30 -c copy output.mp4

Now we can break down our command:

• -i input.mp4: Specifies the input file
• -ss 00:01:30: Sets the start time at 1 minute and 30 seconds
• -t 00:00:30: Sets the duration to 30 seconds
• -c copy: Uses stream copying instead of re-encoding, making the process much faster.
• output.mp4: Names the output file

Note on flags position in the command

FFmpeg’s -ss and -t flags control seeking and duration, but their placement in the command greatly affects both performance and accuracy.

When -ss is placed before the input (-i), FFmpeg performs a fast seek to the nearest keyframe before the specified time. This method minimizes processing time by avoiding the decoding of frames that come before the keyframe, but it may not be frame-accurate if the desired start time doesn't align exactly with a keyframe.

Conversely, when -ss is used as an output option (placed before the output file), FFmpeg decodes and discards input until the timestamps reach the designated position. This ensures precise, frame-accurate trimming, which is beneficial when exact timing is crucial, though it requires more processing time since every frame up to that point is decoded.

Trimming with End Time Instead of Duration

If you prefer to specify the end time rather than the duration, use the -to flag instead of -t. The -to [end_time] will sets the end time, and FFmpeg will automatically calculate the duration:

ffmpeg -i input.mp4 -ss 00:01:30 -to 00:02:00 -c copy output.mp4

This command will trim from 1:30 to 2:00 in the video.

Precise Trimming with Keyframes

When using -c copy, FFmpeg will trim at the nearest keyframe, which might not be exactly where you specified. For more precise trimming, you can force re-encoding:

ffmpeg -i input.mp4 -ss 00:01:30 -t 00:00:30 -c:v libx264 -c:a aac -strict experimental output.mp4

This provides frame-accurate trimming but takes longer since it re-encodes the video.

Let's break down the key components of this command:

• -c:v libx264: Re-encodes the video stream using the H.264 (libx264) codec, which is popular for its efficiency and quality.
• -c:a aac: Re-encodes the audio stream using the AAC codec
• -strict experimental: Allows the use of experimental features, required in some versions of FFmpeg for AAC encoding.

Optimizing the Trimming Process

For better performance, you can place the -ss flag before the input file to make FFmpeg seek faster:

ffmpeg -ss 00:01:30 -i input.mp4 -t 00:00:30 -c copy output.mp4

This tells FFmpeg to seek to the position first before starting to process the file, which can be significantly faster for large files.

Lossless Trimming for Specific Formats

For certain formats like MP4, you can perform lossless trimming:

ffmpeg -i input.mp4 -ss 00:01:30 -to 00:02:15 -c copy -avoid_negative_ts 1 output.mp4

The -avoid_negative_ts 1 option helps prevent timestamp issues in the output file.

Trim Multiple segments

You can trim multiple parts of a video by running FFmpeg multiple times or using filter_complex with the trim filter.

ffmpeg -i input.mp4 -filter_complex \
"[0:v]trim=start=60:end=120,setpts=PTS-STARTPTS[v]; [0:a]atrim=start=60:end=120,asetpts=PTS-STARTPTS[a]" \
-map "[v]" -map "[a]" output.mp4

This example uses the trim filter for video and atrim for audio, which gives you precise control over the segment you extract.

This FFmpeg command trims both the video and audio streams from the input file between 60 and 120 seconds using a complex filter.

Here’s a detailed breakdown:

• -filter_complex: Begins a complex filter graph that processes multiple streams.
  • "[0:v]trim=start=60:end=120,setpts=PTS-STARTPTS[v]; [0:a]atrim=start=60:end=120,asetpts=PTS-STARTPTS[a]":
    • [0:v]: Selects the video stream from the first input.
    • trim=start=60:end=120: Trims the video, keeping only the segment from 60 to 120 seconds.
    • setpts=PTS-STARTPTS: Resets the presentation timestamps, so the trimmed video starts at 0.
    • [v]: Labels the processed video stream for mapping.
    • [0:a]: Selects the audio stream from the first input.
    • atrim=start=60:end=120: Trims the audio to match the video segment.
    • asetpts=PTS-STARTPTS: Resets the audio timestamps, aligning it with the trimmed video.
    • [a]: Labels the processed audio stream for mapping.
• -map "[v]": Maps the labeled video stream ([v]) from the filter graph to the output.
• -map "[a]": Maps the labeled audio stream ([a]) from the filter graph to the output.
• output.mp4: Specifies the name of the output file that will contain the trimmed segment.

Mapping in FFmpeg lets you explicitly choose which streams (video, audio, subtitles, etc.) are included in the final output. When you use a complex filter graph, you assign labels to the processed streams so you can refer to them later. In this example:

• [v]: This label is assigned to the processed video stream after it has been trimmed and had its timestamps reset.
• [a]: This label is assigned to the processed audio stream after it has been similarly trimmed and adjusted.

The -map options then explicitly select these labeled streams for inclusion in the output file:

• -map "[v]": Tells FFmpeg to include the video stream labeled [v] in the final output.
• -map "[a]": Tells FFmpeg to include the audio stream labeled [a] in the final output.

This approach ensures that only the streams you processed and labeled are included in the output, giving you precise control over the final result.

You can use any valid label for your streams. The labels do not have to be [v] or [a] specifically; they can be any unique identifier you choose, such as [video] or [audio]. The key is that the label you assign in the filter graph must match the label you reference in the -map option. Using common labels like [v] and [a] is simply a convention for clarity.

Automate FFmpeg in Programmatic Video Workflows

When implementing video trimming for many videos in your workflows, you'll likely want to execute FFmpeg commands programmatically.

If you need to trim multiple videos with the same parameters (for example, extracting a specific segment from each video in a folder), you can automate the process using a script.

Below is a sample script that processes all video files in a directory, trimming each one to a specific segment.

On Linux and macOS:

#!/bin/bash

  # This script trims multiple video files in a directory
  # Usage: ./trim_videos.sh [input_directory] [output_directory] [start_time] [end_time]
  
  # Check if FFmpeg is installed
  if ! command -v ffmpeg &> /dev/null; then
      echo "Error: FFmpeg is not installed. Please install it first."
      exit 1
  fi
  
  # Check if correct number of arguments is provided
  if [ "$#" -ne 4 ]; then
      echo "Usage: $0 [input_directory] [output_directory] [start_time] [end_time]"
      echo "Example: $0 ./raw_videos ./trimmed_videos 00:00:30 00:01:45"
      exit 1
  fi
  
  INPUT_DIR="$1"
  OUTPUT_DIR="$2"
  START_TIME="$3"
  END_TIME="$4"
  
  # Create output directory if it doesn't exist
  mkdir -p "$OUTPUT_DIR"
  
  # Count total number of video files
  total_files=$(find "$INPUT_DIR" -type f \( -name "*.mp4" -o -name "*.avi" -o -name "*.mov" -o -name "*.mkv" \) | wc -l)
  current_file=0
  
  # Process each video file
  find "$INPUT_DIR" -type f \( -name "*.mp4" -o -name "*.avi" -o -name "*.mov" -o -name "*.mkv" \) | while read -r video_file; do
      # Get the filename without path
      filename=$(basename "$video_file")
      # Create output filename
      output_file="$OUTPUT_DIR/trimmed_$filename"
      
      # Increment counter
      ((current_file++))
      
      # Display progress
      echo "Processing file $current_file of $total_files: $filename"
      
      # Trim the video
      ffmpeg -i "$video_file" -ss "$START_TIME" -to "$END_TIME" -c copy "$output_file" -hide_banner -loglevel warning
      
      # Check if the trimming was successful
      if [ $? -eq 0 ]; then
          echo "Successfully trimmed: $filename -> $output_file"
      else
          echo "Error trimming: $filename"
      fi
  done
  
  echo "All videos processed. Trimmed videos are in $OUTPUT_DIR"

The script takes four arguments:

1. Input directory containing the videos
2. Output directory where trimmed videos will be saved
3. Start time for trimming
4. End time for trimming

To run the script:

1. Save the script as trim_videos.sh.

2. Make it executable with the command:

   chmod +x trim_videos.sh

3. Execute the script:

   ./trim_videos.sh ./raw_videos ./trimmed_videos 00:00:30 00:01:45

   This will trim all videos in the raw_videos directory, cutting them from 30 seconds to 1 minute and 45 seconds, and save the results in the trimmed_videos directory.

How the script works:

• Set parameters: the variables START_TIME and END_TIME determine the segment of the video you want to keep.
• Output directory: the script creates a directory (OUTPUT_DIR) to store the trimmed videos.
• Loop through files: the for loop goes through every .mp4 .avi .mov .mkv file in the directory.
• Trim each video: FFmpeg is called for each file with the specified start time and end time. The -c copy option ensures the video is trimmed without re-encoding, preserving quality and speeding up the process.
• Feedback: the script prints messages to the terminal to let you know the progress.

On Windows:

@echo off
setlocal EnableDelayedExpansion

REM Define the start time and duration for the trim
set "START_TIME=00:01:00"
set "DURATION=00:00:30"

REM Create an output directory if it doesn't exist
set "OUTPUT_DIR=trimmed_videos"
if not exist "%OUTPUT_DIR%" mkdir "%OUTPUT_DIR%"

REM Loop through each MP4 file in the current directory
for %%F in (*.mp4) do (
    echo Processing %%F...
    set "OUTPUT_FILE=%OUTPUT_DIR%\trimmed_%%F"
    ffmpeg -i "%%F" -ss %START_TIME% -t %DURATION% -c copy "!OUTPUT_FILE!"
    echo Saved trimmed video as "!OUTPUT_FILE!"
)
echo All videos processed.
pause

Explanation of the script

• Set parameters: the script begins by defining two environment variables, START_TIME and DURATION, which determine the segment of the video to extract. In this case, trimming starts at 1 minute into the video and lasts for 30 seconds.
• Video type: the script only looks for .mp4 video type. You can change it to process different video types.
• Create output directory: the OUTPUT_DIR variable is set to trimmed_videos. The script checks if this directory exists with the if not exist condition. If it doesn’t exist, it creates the directory using mkdir.
• Loop through files: the for loop iterates over every .mp4 file in the current directory. For each file, the loop variable %%F holds the current file name.
• Trim each Video: inside the loop, the script constructs the output file name by prepending trimmed_ to the original file name and storing it in the OUTPUT_FILE variable. It then calls FFmpeg with the specified parameters: using -ss to set the start time, -t to define the duration, and -c copy to copy the streams without re-encoding for a faster operation.
• Feedback: the script echoes messages to the command prompt to inform the user which file is currently being processed and confirms once the trimmed video is saved.
• Completion: after processing all the videos, the script echoes "All videos processed." and uses pause to keep the window open until a key is pressed, so you can review the output.

To run the script:

1. Save the script: copy the batch script code into a text editor and save it as trim_videos.bat.
2. Open command prompt: press Win + R, type cmd, and press Enter to open the Command Prompt.
3. Navigate to the script's directory: use the cd command to change to the directory where trim_videos.bat is saved. For example:

   cd C:\path\to\your\script

4. Run the script: type the name of the script and press Enter:

   trim_videos.bat

5. Trimmed videos will be saved in the trimmed_videos directory. Once all files are processed, the script will display "All videos processed." and wait for a key press before closing the Command Prompt.

Common Issues and Solutions

Audio-Video Sync Problems

Sometimes trimming can cause audio and video to go out of sync. In such cases, try:

ffmpeg -i input.mp4 -ss 00:01:30 -t 00:00:30 -c:v libx264 -c:a aac -vsync 0 output.mp4

The -vsync 0 flag can help maintain synchronization.

The -vsync 0 option in FFmpeg disables video synchronization adjustments, effectively passing frames through without modifying their timing. This "passthrough" mode means that FFmpeg will neither duplicate nor drop frames to achieve a constant frame rate.

Using -vsync 0 can be beneficial when you need to preserve the original timing and order of frames, which is particularly important for applications requiring frame-accurate output. However, if the input has irregular frame intervals or if your output format expects a constant frame rate, this option might result in playback issues such as dropped or duplicated frames.

Quality Loss

If you notice quality loss when using re-encoding, try:

ffmpeg -i input.mp4 -ss 00:01:30 -t 00:00:30 -c:v libx264 -preset slow -crf 18 -c:a aac -b:a 192k output.mp4

Let's define some terms before breaking down the command.

Encoding Preset: An encoding preset is a configuration option that balances encoding speed and compression efficiency. A slower preset (such as "slow" or "veryslow") uses more advanced compression techniques, resulting in better quality and smaller file sizes at the expense of longer encoding times. Conversely, a faster preset (like "fast" or "ultrafast") speeds up the encoding process but may yield larger files and lower overall quality.

Audio Bitrate: Audio bitrate specifies the amount of data allocated to the audio stream per second, measured in kilobits per second (kbps). A higher audio bitrate (for example, 192k) generally provides better audio quality because more data is used to capture the sound, though it also increases the file size. Lower bitrates reduce file size but can compromise the clarity and detail of the audio.

Now, let's take a closer look at the new parts of the command:

• -preset slow: Uses the slow encoding preset for libx264. This preset increases encoding time but improves compression efficiency and overall quality.
• -crf 18: Sets the Constant Rate Factor to 18. Lower CRF values yield higher quality; 18 is considered near visually lossless while maintaining reasonable file size.
• -b:a 192k: Sets the audio bitrate to 192 kbps, ensuring good audio quality.

Conclusion

Trimming videos using FFmpeg is a straightforward process once you understand the command-line options available. Whether you need a quick one-off trim or are looking to automate the process for multiple videos, FFmpeg provides flexible and powerful options, making it an excellent fit for automated video creation workflows.

While basic trimming is straightforward, you can enhance the process by creating custom scripts for batch processing, which saves significant time when working with multiple videos.

In future tutorials, we'll explore more advanced FFmpeg operations such as concatenating videos, adding overlays, and applying filters - all essential components of a robust programmatic video creation pipeline.