How can I use ffmpeg to split MPEG video into 10 minute chunks?

There is often a need in the open source or active developer community to publish large video segments online. (Meet-up videos, campouts, tech talks…) Being that I am a developer and not a videographer I have no desire to fork out the extra scratch on a premium Vimeo account. How then do I take a 12.5 GB (1:20:00) MPEG tech talk video and slice it into 00:10:00 segments for easy uploading to video sharing sites?

Asked By: Gabriel

||
$ ffmpeg -i source-file.foo -ss    0 -t 600  first-10-min.m4v
$ ffmpeg -i source-file.foo -ss  600 -t 600 second-10-min.m4v
$ ffmpeg -i source-file.foo -ss 1200 -t 600  third-10-min.m4v
...

Wrapping this up into a script to do it in a loop wouldn’t be hard.

Beware that if you try to calculate the number of iterations based on the duration output from an ffprobe call that this is estimated from the average bit rate at the start of the clip and the clip’s file size unless you give the -count_frames argument, which slows its operation considerably.

Another thing to be aware of is that the position of the -ss option on the command line matters. Where I have it now is slow but accurate. The linked article describes fast-but-inaccurate and slower-but-still-accurate alternative formulations. You pay for the latter with a certain complexity.

All that aside, I don’t think you really want to be cutting at exactly 10 minutes for each clip. That will put cuts right in the middle of sentences, even words. I think you should be using a video editor or player to find natural cut points just shy of 10 minutes apart.

Assuming your file is in a format that YouTube can accept directly, you don’t have to reencode to get segments. Just pass the natural cut point offsets to ffmpeg, telling it to pass the encoded A/V through untouched by using the "copy" codec:

$ ffmpeg -i source.m4v -ss       0 -t  593.3 -c copy part1.m4v
$ ffmpeg -i source.m4v -ss   593.3 -t 551.64 -c copy part2.m4v
$ ffmpeg -i source.m4v -ss 1144.94 -t 581.25 -c copy part3.m4v
...

The -c copy argument tells it to copy all input streams (audio, video, and potentially others, such as subtitles) into the output as-is. For simple A/V programs, it is equivalent to the more verbose flags -c:v copy -c:a copy or the old-style flags -vcodec copy -acodec copy. You would use the more verbose style when you want to copy only one of the streams, but re-encode the other. For example, many years ago there was a common practice with QuickTime files to compress the video with H.264 video but leave the audio as uncompressed PCM; if you ran across such a file today, you could modernize it with -c:v copy -c:a aac to reprocess just the audio stream, leaving the video untouched.

The start point for every command above after the first is the previous command’s start point plus the previous command’s duration.

Answered By: Warren Young

Note the exact punctuation of the alternative format is -ss mm:ss.xxx. I struggled for hours trying to use the intuitive-but-wrong mm:ss:xx to no avail.

$ man ffmpeg | grep -C1 position

-ss position
Seek to given time position in seconds. “hh:mm:ss[.xxx]” syntax is also supported.

References here and here.

Answered By: Mark Hudson

Faced the same problem earlier and put together a simple Python script to do just that (using FFMpeg). Available here: https://github.com/c0decracker/video-splitter, and pasted below:

#!/usr/bin/env python
import subprocess
import re
import math
from optparse import OptionParser
length_regexp = 'Duration: (d{2}):(d{2}):(d{2}).d+,'
re_length = re.compile(length_regexp)
def main():
    (filename, split_length) = parse_options()
    if split_length <= 0:
        print "Split length can't be 0"
        raise SystemExit
    output = subprocess.Popen("ffmpeg -i '"+filename+"' 2>&1 | grep 'Duration'",
                              shell = True,
                              stdout = subprocess.PIPE
    ).stdout.read()
    print output
    matches = re_length.search(output)
    if matches:
        video_length = int(matches.group(1)) * 3600 + 
                       int(matches.group(2)) * 60 + 
                       int(matches.group(3))
        print "Video length in seconds: "+str(video_length)
    else:
        print "Can't determine video length."
        raise SystemExit
    split_count = int(math.ceil(video_length/float(split_length)))
    if(split_count == 1):
        print "Video length is less then the target split length."
        raise SystemExit
    split_cmd = "ffmpeg -i '"+filename+"' -vcodec copy "
    for n in range(0, split_count):
        split_str = ""
        if n == 0:
            split_start = 0
        else:
            split_start = split_length * n
            split_str += " -ss "+str(split_start)+" -t "+str(split_length) + 
                         " '"+filename[:-4] + "-" + str(n) + "." + filename[-3:] + 
                         "'"
    print "About to run: "+split_cmd+split_str
    output = subprocess.Popen(split_cmd+split_str, shell = True, stdout =
                              subprocess.PIPE).stdout.read()
def parse_options():
    parser = OptionParser()
    parser.add_option("-f", "--file",
                      dest = "filename",
                      help = "file to split, for example sample.avi",
                      type = "string",
                      action = "store"
    )
    parser.add_option("-s", "--split-size",
                      dest = "split_size",
                      help = "split or chunk size in seconds, for example 10",
                      type = "int",
                      action = "store"
    )
    (options, args) = parser.parse_args()
    if options.filename and options.split_size:
        return (options.filename, options.split_size)
    else:
        parser.print_help()
        raise SystemExit
if __name__ == '__main__':
    try:
        main()
    except Exception, e:
        print "Exception occured running main():"
        print str(e)
Answered By: c0decracker

Here is the one line solution:

ffmpeg -i input.mp4 -c copy -map 0 -segment_time 00:20:00 -f segment output%03d.mp4

Please note that this does not give you accurate splits, but should fit your needs. It will instead cut at the first frame after the time specified after segment_time, in the code above it would be after the 20 minute mark.

If you find that only the first chunk is playable, try adding -reset_timestamps 1 as mentioned in the comments.

ffmpeg -i input.mp4 -c copy -map 0 -segment_time 00:20:00 -f segment -reset_timestamps 1 output%03d.mp4
Answered By: Jon

Just use what is built into ffmpeg to do exactly this.

ffmpeg -i invid.mp4 -threads 3 
       -vcodec copy -f segment -segment_time 10:00 
       -reset_timestamps 1 
       cam_out_h264_%02d.mp4

This will split it into roughly 10-minute chunks, split at the relevant keyframes, and will output to the files
cam_out_h264_01.mp4, cam_out_h264_02.mp4, etc.

Answered By: John Allard

If you want to create really same Chunks must force ffmpeg to create i-frame on the every chunks’ first frame so you can use this command for create 0.5 second chunk.

ffmpeg -hide_banner  -err_detect ignore_err -i input.mp4 -r 24 -codec:v libx264  -vsync 1  -codec:a aac  -ac 2  -ar 48k  -f segment   -preset fast  -segment_format mpegts  -segment_time 0.5 -force_key_frames  "expr: gte(t, n_forced * 0.5)" out%d.mkv
Answered By: alireza akbaribayat

An Alternate more readable way would be

ffmpeg -i input.mp4 -ss 00:00:00 -to 00:10:00 -c copy output1.mp4
ffmpeg -i input.mp4 -ss 00:10:00 -to 00:20:00 -c copy output2.mp4

/**
* -i  input file
* -ss start time in seconds or in hh:mm:ss
* -to end time in seconds or in hh:mm:ss
* -c codec to use
*/

Here’s the source and list of Commonly used FFmpeg commands.

Answered By: Niket Pathak
#!/bin/bash

if [ "X$1" == "X" ]; then
    echo "No file name for split, exiting ..."
    exit 1
fi

if [ ! -f "$1" ]; then
    echo "The file '$1' doesn't exist. exiting ..."
    exit 1
fi

duration=$(ffmpeg -i "$1" 2>&1 | grep Duration | sed 's/^.*Duration: (.*)..., start.*$/1/' | awk -F: '{ print ($1 * 3600) + ($2 * 60) + $3 }')      #'
split_time=${split_time:-55}
time=0
part=1

filename=${file%%.*}
postfix=${file##*.}

while [ ${time} -le ${duration} ]; do

echo    ffmpeg -i "$1" -vcodec copy -ss ${time} -t ${split_time} "${filename}-${part}.${postfix}"
    (( part++ ))
    (( time = time + split_time ))

done
Answered By: Alex_Shilli

One line solution


for i in {3..100}; do ffmpeg -i input.mp4 -ss $(($((i))*600)) -t $(($((i+1))*600)) $i.mp4 ; done;

Answered By: Trect

Please have a look into below command

fun trim(): Array<String?>{
        val cmdList = ArrayList<String>()
        var cmds: Array<String?>? = null
        try{
            cmdList.add("-y")

            cmdList.add("-ss")
            cmdList.add(startduration.toString())
            cmdList.add("-t")
            cmdList.add(endduration.toString())
            cmdList.add("-i")
            cmdList.add(sourcevideopath)
            cmdList.add("-vcodec")
            cmdList.add("copy")

            cmdList.add("-movflags")
            cmdList.add("faststart")
            cmdList.add("-preset")
            cmdList.add("ultrafast")

            cmdList.add(outputvideopath)

            cmds = arrayOfNulls<String>(cmdList.size)
            cmdList.toArray(cmds)

        }catch (e:Exception){
            e.printStackTrace()
        }
        return cmds!!
    }
Answered By: user478635
ffmpeg -i input.mp4 -force_key_frames expr:gte(t,n_forced*600) -f segment -segment_time 600 -reset_timestamps 1 -map 0 -segment_format_options movflags=+faststart output_%03d.mp4

To split the video more accurately, you can use the -force_key_frames option to specify keyframes at the desired split points.

  • -f segment -segment_time 600 sets the segment length
  • gte(t, n_forced*600): This is the expression itself, where:
    • t represents the current time of the video frame being processed.
    • n_forced represents the number of keyframes that have been forced so far.
    • *600 multiplies n_forced by 600, which is the time interval in seconds.
Answered By: Yashik
Categories: Answers Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.