If the JPEG encoding step is too performance intensive, you could always store the frames uncompressed as BMP images:

ffmpeg -i file.mpg -r 1/1 $filename%03d.bmp

This also has the advantage of not incurring more quality loss through quantization by transcoding to JPEG. (PNG is also lossless but tends to take much longer than JPEG to encode.)

I have no idea if what you're doing is optimal, but "playing the video" to extract frames is essentially what has to happen, at least a little, if the frame you're extracting is not an I-frame (most frames are not).

The chosen frame is likely represented as the accumulated differences since the last complete frame, which is what interframe compression does. In order to extract it, a program must read and reconstruct the intervening frames -- not from the beginning of the video, just from the most recent complete frame

Depending on how many frames you need from each video, it might make sense to first convert to an "all-I" codec like MJPEG, where every frame stands alone. Then extracting any given frame would be much faster. When done you can delete the converted file.

Ok the code I posted above in the original post is the only solution I've found so far for faster image extraction. Sometimes gives me speed upto 50.

ffmpeg -i in.mkv -vf "select='if(not(floor(mod(t,6)))*lt(ld(1),1),st(1,1)+st(2,n)+st(3,t));if(eq(ld(1),1)*lt(n,ld(2)+1),1,if(trunc(t-ld(3)),st(1,0)))'" -vsync 0 %4d.png

If you are interested in random image extraction (based on keyframe) to get higher speed, use -skip_frame nokey.

Join simple filters with a comma:

ffmpeg -i video.avi -vf "scale=320:240,fps=25" frames/c01_%04d.jpeg

fps

When using the fps filter to extract frames be aware that if the input frame rate:

• is the same as the fps value then the filter is doing nothing and you can remove it.

• is higher than the fps value then some frames will be omitted to match the fps value. If this is the case then use fps before scale and the process will be faster.

• is lower than the fps value then some frames will be duplicated to match the fps value.

If you want to simply extract all frames then remove the fps filter.

scale

Consider declaring just width or height and using -1 as the value for the other, such as 320:-1 or -1:240. Doing this will allow the filter to automatically choose the proper value while preserving the aspect ratio. This will prevent stretching of the output image aspect ratio.

jpeg

Use -q:v or -qscale:v to control quality.

Use

ffmpeg -skip_frame nokey -i file -vsync 0 -frame_pts true out%d.png

skip_frame tells the decoder to process only keyframes. -vsync 0 (in this command) preserves timestamps. -frame_pts sets the numeral portion of the output image filename to represent the timestamp. The interpretation of the number requires you to know the framerate e.g. if the framerate is 30 then an image name of out75 corresponds to a timestamp of 75/30 = 2.50 seconds. You can add -r 1000 if you want numbers to represent milliseconds.

Using -r 0.1 sets the output framerate to 0.1Hz, but it's not guaranteed to get frame from the input video exactly every 10 seconds (I am not sure why).

One way for solving it is using select filter.

Example (without GPU acceleration):

ffmpeg -i input.mp4 -vf "select=bitor(gte(t-prev_selected_t\,10)\,isnan(prev_selected_t))" -vsync 0 f%09d.jpg

• bitor(gte(t-prev_selected_t\,10) is 1 when difference between "passed" timestamps is grater of equal 10 seconds.
  When expression is evaluated to 1, the frame is "selected" and passed to the output.
• bitor with isnan(prev_selected_t) passes the first frame, where prev_selected_t is NaN (has no value).
• -vsync 0 applies "passthrough" - Each frame is passed with its timestamp from the demuxer to the muxer.

Here is an example with scale_cuda and thumbnail_cuda:

ffmpeg \
    -loglevel error \
    -hwaccel cuvid \
    -hwaccel_output_format cuda \
    -c:v h264_cuvid \
    -i "$video_file" \
    -filter:v "scale_cuda=w=-1:h=100,thumbnail_cuda=2,hwdownload,format=nv12,select=bitor(gte(t-prev_selected_t\,10)\,isnan(prev_selected_t))" \
    -vsync 0 \
    -color_range 2 \
    f%09d.jpg   

• Due to the usage of thumbnail_cuda filter, we have to place the select filter at the end.

Testing:
Build synthetic video with frame counter at 10fps:

ffmpeg -y -f lavfi -r 10 -i testsrc=size=128x72:rate=1:duration=1000 -vf setpts=N/10/TB -vcodec libx264 -pix_fmt yuv420p input.mp4

Output frames after executing the above command:

As you can see, the selected frames are exactly every 10 seconds.