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.

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.

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 …

I realize this is an old question, but in case someone else (like me) stumbles upon it, the answer is that the time code skips you see are not an error, but work as intended.

Since you have specified 29.97 fps drop frame (by using a semicolon in the timecode) the two-frame skip is according to the specification (read more here: https://en.wikipedia.org/wiki/SMPTE_timecode#Drop_frame_timecode).

In short: Since 29.97 is a fractional speed, and a video file cannot contain fractional frames, frames have to be dropped to maintain a correlation between the time code and wall clock time. Note that no actual video frames are dropped, only time codes are skipped. The specification says that on the first second of every minute, the first two frames (zero and one) are skipped, except for when the minute value is divisible by ten.

So seeing the time code go from 00:00:59:29 to 00:01:00:02 is expected behaviour. In order not to get this you have to switch to another frame rate, and write the time code using only colons: 00:00:00:00.

ffmpeg does not do sub-pixel overlay. Computed co-ordinates are truncated to integers.

The closest to getting a smooth result is to overlay a large PNG on a large background and then downscale the result to the final resolution i.e. [largebg][largefg]overlay=...,scale=300:250:flags=bicubic

If you want to remove a single I-frame, you have to extract the bitstream to an Annex B format (e.g. ffmpeg -i input.mp4 -c:v copy -an output.h264, and then find the bytes that represent the NAL unit(s) containing the frame(s) you want to remove. Remove those bytes until the next start code, and save the stream.

Or, you could splice the video by using the -frames:v option to extract the first n frames:

ffmpeg -i input.h264 -c:v copy -frames:v n output.h264

Then, using the -ss parameter, you could seek to the position where you want to start again, and cut from there the same way. You could find out the position by multiplying n+1 times the framerate.

There is no simpler way I know of if you do not want to re-encode.