For your workload, there are two potential solutions:
1. FFmpeg's libplacebo filter integration:
The platform-agnostic libplacebo project may be a better fit for the interplolation mode(s) you're looking for, integrated in FFmpeg as a GPU-accelerated filter.
It's dependency is a Vulkan implementation with a fallback to llvm if needed. This can be toggled on via -init_hw_device vulkan:llvmpipe in FFmpeg on systems with LLVM installed AND no need to run this on a discrete GPU.
As currently documented, libplacebo's frame_mixer private option has multiple kernels that can be selected at runtime, based on the desired temporal frame mixing mode:
(a). none: Disables frame mixing, giving a result equivalent to "nearest neighbour" semantics. This is the default.
(b).oversample: This kernel oversamples the input video to create a "Smooth Motion"-type effect: if an output frame would exactly fall on the transition between two video frames, it is blended according to the relative overlap. This is the recommended option whenever preserving the original subjective appearance is desired.
(c). mitchell_clamp: This is a larger filter kernel that smoothly interpolates multiple frames in a manner designed to eliminate ringing and other artefacts as much as possible. This is the recommended option wherever maximum visual smoothness is desired. It's also the most compute-intensive mode.
(d)linear: Linear blend/fade between frames. Especially useful for constructing e.g. slideshows.
All Interpolation operations require that the private filter option fps be set to the desired output frame rate. This value can be rational, e.g. 60000/1001 (59.97fps) and 30000/1001 (for NTSC's 29.97fps) or a decimal value, eg 30, etc. With the fps option set, input video frames will then be interpolated to rescale the video to the specified target framerate as governed by the aforementioned frame_mixer option.
A trivial example is provided below demonstrating the use of the mitchell_clamp temporal frame mixing mode with VFR input to smoothed constant 60 fps output:
ffmpeg -hide_banner -i "input" \
-init_hw_device vulkan \
-vf "hwupload,libplacebo=fps=60:frame_mixer=mitchell_clamp,hwdownload" \
-c:v libx264 -crf 18 "output.mkv"
In my testing, it's a very performant filter, allowing for real-time throughput with multiple 1:N transcoding workflows on both Intel's OneVPL and NVIDIA's NVENC encoder wrappers.
An excellent guide to libplacebo usage with NVIDIA GPUs is shown here, with additional documentation on the same over at Jellyfin's github issues section.
2. Intel's vpp_qsv filter implementation:
The second option is strictly tied to Intel's OneVPL and (the currently discontinued) QuickSync-capable systems running a supported Intel GPU. In this case, and with a current FFmpeg build, you may use the vpp_qsv filter. It has a private framerate option with similar arguments to libplacebo's private fps option.
You may print out the filter's usage options via:
ffmpeg -h filter=vpp_qsv
With Intel, the interpolation modes available are dependent on the specific runtime(s) selected in the FFmpeg build, and as such, performance and conformance are very dependent on BOTH the runtime in use (legacy QSV vs modern OneVPL) and the GPU in use. See this issue for more on this application notice.
Disclaimer:
Your mileage may vary, depending on your input file characteristics,the selected encoder wrapper(s) in use and the target interpolation requirements that may differ from what libplacebo and vpp_qsv filters can cover. Test coverage for this is recommended before deciding on whether switching away from minterpolate covers your specific requirements.
