To work accurately, first convert the video to RAW YUV bitstream (if it is not already) by:

ffmpeg -i input.mp4 -an -vcodec rawvideo -pix_fmt yuv420p rawbitstream.yuv

Next step: The select filter takes an expression, where n is the frame number.

ffmpeg -r 2 -s WxH -i rawbitstream.yuv -filter:v select="mod(n-1\,2)" \
-c:v rawvideo -r 1 -format rawvideo -pix_fmt yuv420p -an odd.yuv

ffmpeg -r 2 -s WxH -i rawbitstream.yuv -filter:v select="not(mod(n-1\,2))" \
-c:v rawvideo -r 1 -format rawvideo -pix_fmt yuv420p -an even.yuv

To have ffmpeg not duplicate frames, you have to force half of the framerate of your input - so you set "2" as the input and "1" to the output. Don't forget to replace the WxH with the actual dimensions of your clip because the raw bitstream doesn't have a header that carries this information.

Instead of the above, another possibility would be to add the setpts filter to set new timestamps for the output. But be careful since it drops frames not accurately. Here, 25 is the actual output frame rate you want:

ffmpeg -i input.mp4 -filter:v select="mod(n-1\,2)",setpts="N/(25*TB)" \
-c:v rawvideo -r 12.5 -format rawvideo -pix_fmt yuv420p -an odd.yuv

ffmpeg -i input.mp4 -filter:v select="not(mod(n-1\,2))",setpts="N/(25*TB)" \
-c:v rawvideo -r 12.5 -format rawvideo -pix_fmt yuv420p -an even.yuv

You can of course choose another pixel format (any of ffmpeg -pix_fmts). Make sure that when reading the file you know the pixel size and pixel format:

ffmpeg -f rawvideo -s:v 1280x720 -pix_fmt yuv420p input.yuv …

At first glance it seems like you should be able to use a second step in your filter to select only even or odd numbered I frames, but after testing it doesn't seem like this is actually possible.

When looking at frame numbers we have two choices: n, which seems to be the absolute frame number, and selected_n, which seems to be the filtered frame number. The ffmpeg filter docs are not very clear on how these values are defined.

In my tests, it looks like if you use a filter like this:

select='eq(pict_type,I)*not(mod(n,2))'

You will get the same number of frames as you would if you omitted the *not(mod(n,2)), which I assume is because I frames will always fall on odd-numbered n due to how the encoding works.

If we try using selected_n instead, though, I find that only a single frame is ever selected. This makes sense because the filter can't ever match an even-number of selected frames, so it will only ever match the first one.

Given this, I think your only choice here is to use a 2-stage approach, where you use one run of ffmpeg to get your iframes, then a second run of ffmpeg to drop every other frame. Something like:

ffmpeg -i $FILE -vf "select='eq(pict_type,I)' $TMPFILE
ffmpeg -i $TMPFILE -vf "select='not(mod(n,2))' $CONVERTED_FILE

I ended up writing a python script to do this

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
'''
converts sequence of images to video
uses glob pattern and allows skipping images

---
uses sk-video
```> pip install sk-video```

backend uses ffmpeg or libav

TODO:
- add more input & output dict opts 

For full list of flags see
- https://ffmpeg.org/ffmpeg.html 
- https://trac.ffmpeg.org/wiki/Encode/H.264

Note: Not using opencv2.VideoWriter because it fails silently on Anaconda

'''
from __future__ import print_function
from __future__ import division

import argparse
import glob
import os
from imageio import imread
from skvideo.io import FFmpegWriter
from tqdm import tqdm
from pprint import pprint

parser = argparse.ArgumentParser()
parser.add_argument('-i', '--input_folder', default='.', help='path to folder containing images')
parser.add_argument('-p', '--file_pattern', default='*.png', help='Unix filename pattern. For details see https://docs.python.org/2/library/fnmatch.html')
parser.add_argument('-o', '--output_path', default='output.mp4', help='path to output video file')
parser.add_argument('-n', '--every', default=10, type=int, help='include every nth image. i.e. every==1 uses every image. every==2 takes every other image ')
parser.add_argument('-m', '--max_count', default=None, type=int, help='if > 0, cap at this many frames')
parser.add_argument('-v', '--verbose', default=False, type=int, help='dump a lot of stuff to the console')

# ffmpeg args
parser.add_argument('-r', '--fps', default='30', type=str, help='frames per second')
parser.add_argument('-vcodec', default='libx264', type=str, help='output video codec')
parser.add_argument('-b', '--bitrate', default=None, type=str, help='bitrate')
parser.add_argument('-crf', default=None, type=str, help='Constant Rate Factor. The range of the CRF scale is 0–51, where 0 is lossless, 23 is the default, and 51 is worst quality possible. A lower value generally leads to higher quality, and a subjectively sane range is 17–28. Consider 17 or 18 to be visually lossless or nearly so; it should look the same or nearly the same as the input but it isnt technically lossless')
args = parser.parse_args()


#%% Get input file list
glob_path = os.path.join(os.path.expanduser(os.path.expandvars(args.input_folder)), args.file_pattern)

# read all files in folder matching pattern
print('Reading folder "{}"'.format(glob_path))
paths = sorted(glob.glob(glob_path))
args.stats = {'file_count_total' : len(paths) }
print(args.stats['file_count_total'], 'files found')

# skip 
if args.every > 1:
    paths = [x for i,x in enumerate(paths) if i % args.every == 0]
    args.stats['file_count_with_skip'] = len(paths)
    print(args.stats['file_count_with_skip'], 'files with skip')

# cap to max_count
if args.max_count:
    paths = paths[:args.max_count]
    args.stats['file_count_capped'] = len(paths)
    print(args.stats['file_count_capped'], 'files after cap')

#%% init video writer with parameters
inputdict = {}
outputdict = {}

if args.fps:
    inputdict['-r'] = args.fps
    outputdict['-r'] = args.fps           

if args.vcodec: outputdict['-vcodec'] = args.vcodec
if args.bitrate: outputdict['-b'] = args.bitrate
if args.crf: outputdict['-crf'] = args.crf

video_writer = FFmpegWriter(args.output_path, inputdict=inputdict, outputdict=outputdict)

#%%
print('Starting with args:')
pprint(vars(args))
for path in tqdm(paths):
    img = imread(path)
    if args.verbose: print('processing file', i, path)
    video_writer.writeFrame(img)

print('\n-')
print('Finished. Video saved at', args.output_path)

video_writer.close()

See FFmpeg documentation regarding select filter https://ffmpeg.org/ffmpeg-filters.html#Examples-160, so to keep every 60th frame use -vf "select=not(mod(n\,60))"

And this has been already discussed with another example here Using select in ffmpeg to choose frames

This select filter should skip the first 5 frames:

$ ffmpeg -i input_file -vf select="gte(n\, 5)" ...

For timespan it's even easier. Here's how you skip the first 30 seconds:

$ ffmpeg -i input_file -ss 30 ...

To skip the first 30 seconds and keep the next 120 seconds of the original video, add -t:

$ ffmpeg -t input_file -ss 30 -t 120 ...

-ss  time_off        set the start time offset
-t   duration        record or transcode "duration" seconds of audio/video

Both -ss and -t take a time duration:

The following examples are all valid time duration:

55 55 seconds

12:03:45 12 hours, 03 minutes and 45 seconds

23.189 23.189 seconds

None of these methods will be perfectly accurate due to the very mechanics of how video compression works (P and B frames can not stand on their own). ffmpeg will try to adjust accordingly:

Note that in most formats it is not possible to seek exactly, so ffmpeg will seek to the closest seek point before position. When transcoding and -accurate_seek is enabled (the default), this extra segment between the seek point and position will be decoded and discarded. When doing stream copy or when -noaccurate_seek is used, it will be preserved.

Refer to the ffmpeg documentation for more.

FFmpeg has a framestep filter to take every nth frame.

There's also mpdecimate, which outputs a frame whenever the input frame is different enough from the previous frame. (so if exactly every 60th frame isn't perfect, you could use mpdecimate instead to detect the changes, and make a potentially VFR video.)

I didn't test this command; post a comment if I screwed it up:

ffmpeg -i in.camrec -vf framestep=60 -r 1/60 -codec copy -map 0 -c:v libx264 -preset medium -crf 16 -movflags +faststart -vsync 2 out.mp4

Or use out.mkv if you like matroska better than the mp4 container.

copy (stream copy) won't work while dropping frames, I think even for an intra-only codec. So your output has to be encoded to some codec. My example uses lossy h.264, but with the quality cranked so high it should be transparent. You could use lossless h.264 (-preset ultrafast -qp 0), -c:v utvideo, or whatever else you like.

-vsync 2 turns on VFR output mode, which for some reason isn't the default in mp4. (but it is in mkv). You'll want that if you use mpdecimate, but you won't need it for framestep.

A quick google didn't tell me if camrec is already lossy or not. If it's lossy, then there's no way to get a file as small but with the same quality as just keeping every 60th CamRec frame without decoding them. (assuming there's an intra-only frame at the point you want one, if the format has any non-intra frames.)

With mjpeg, you can turn a video into a directory of images without decoding, and select whichever ones you want, and mux them up again. Since camrec frames probably aren't a stand-alone image format, it's unlikely there's something similar, so you just have to use video tools. Like I said, don't think ffmpeg can do clever things like frame dropping without decompressing, even for intra-only codecs. Other tools might exist that can do that, for some codecs.

If it's lossless, then it just takes more CPU time to decode / re-encode to a new lossless format.

edit: more about mpdecimate: As noted in the comments, I added some stats logging to mpdecimate.
git pull https://github.com/pcordes/FFmpeg.git mpdecimate
and then build ffmpeg as usual.

Then run ffmpeg -v debug ....
Or ffplav -v debug -vf mpdecimate input.avi

Testing mpdecimate threshold settings with ffplay is a lot faster than making an encode.

Y4M has no timestamps, only framerate in its header. So, if your source has any variability in its framerate, you'll see a shift in apparent timestamp in the Y4M.

e.g.

n     src     y4m
0       0       0
1    0.04    0.04 
2    0.07    0.08
3    0.12    0.12
4    0.21    0.16
5    0.24    0.20
6    0.27    0.24 
...

Over a long period, these perturbations can add up. Here frame #6 in src is at TS of src #5 in Y4M.

Edit: the sample TS file has VFR timestamps.

Use -c:v rawvideo -vsync 0 -vf setpts=N/FRAME_RATE/TB -an and save to .nut.

One-by-one solution

You can use ffmpeg's select filter, which allows you to evaluate an expression using the sequential frame number, and decide whether or not to skip it (and which output to send it to if it isn't skipped).

To generate, for example, the second video where you are splitting into four each time, you would do the following:

ffmpeg -i input_video -vf select='not(mod(n-1\,4)), setpts=0.25*PTS' -an output_video

Change the 4 if you are splitting into a different number, and the 1 if you want a different selection (so for four you would run it four times, starting without subtracting anything, and ending with subtracting three.

The -vf ... -an segment is to get the video to play back at the right speed, and have the right length (which requires removing any audio tracks).

All-at-once solution

The select filter can also split the file and save each output separately. Here is a command that will split the file into k outputs, (change .mp4 if you want a different extension).

k=4;ffmpeg -i INPUT_FILE -an -filter_complex "setpts=`bc -l <<< 1/$k`*PTS[m];[m]select=n=$k:e=mod(n\,$k)+1`for ((i=1; i<=$k; i++)); do echo -n "[a$i]"; done`" `for ((i=1; i<=$k; i++)); do echo -n "-map [a$i] out$i.mp4 "; done`

The loops within the command are just to write out [a1][a2]... and -map [a1] out1.mp4.... Other than that the modification is to use filter_complex, which is required when dealing with multiple outputs, and changing the filter to direct each frame to its own output mod k.

To speed up a video file, by removing frames, the following syntax can be used:

ffmpeg -r:v "Fin*M/1" -i input.mp4 -an -r:v "Fout/1" output.mp4

• "Fout": This is nothing more and less than the number of FPS (Frames Per Second) you want for output.mp4, e.g. 30 FPS.
• "Fin": The number of FPS of input.mp4, for example 25 FPS. You can find this out with: ffmpeg -i input.mp4
• "M": Multiplier, the speed factor you want, e.g. 15 to make the video 15 times faster.
• "Fin * M": So in this example, that's 25 * 15 = 375

The final result of this example is:

ffmpeg -r:v "375/1" -i input.mp4 -an -r:v "30/1" output.mp4

If you want 1/10 of what you have now (when you use -r 1) then use

 -r 0.1

It will get 1 frame every 10 seconds instead of 1 frame every 1 second.

 ffmpeg -i out1.avi -r 0.1 -f image2 image-%3d.jpeg

EDIT:

If you really what every 10th frame from video then you can use select with modulo 10

ffmpeg -i out1.mp4 -vf "select=not(mod(n\,10))" -vsync vfr image_%03d.jpg

but it may gives more images than before.

If video has 25fps then -r 1 gives image every 25th frame. And if video has 60fps then gives image every 60th frame. So it gives less images then this code which get image every 10th frame.