Blur is a program made for easily and efficiently adding motion blur to videos through frame blending.
The amount of motion blur is easily configurable, and there are additional options to enable other features such as interpolating the video's fps. This can be used to generate 'fake' motion blur through frame blending the interpolated footage. This motion blur does not blur non-moving parts of the video, like the HUD in gameplay footage.
As visible from these images, the interpolated 60fps footage produces motion blur that is comparable to actual 600fps footage.
To install blur for Windows, just download and run the installer. Other operating systems are not currently supported.
For manual installation, see manual installation
- Open the executable and drag a video file onto the console window, or directly drop video files onto the executable file.
- A config file will be generated in the video's directory, which can be modified to suit your needs.
- The program will process the inputted video according to the configuration file located in the same folder as the video, and will output the blurred version to the same directory with " - blur" appended.
The program can also be used in the command line, use -h or --help for more information.
- blur - whether or not the output video file will have motion blur
- blur amount - if blur is enabled, this is the amount of motion blur (0 = no blur, 1 = fully blend every frame together, 1+ = more blur/ghosting)
- blur output fps - if blur is enabled, this is the fps the output video will be. can be a framerate (e.g. 600) or a multiplier (e.g. 5x)
- blur weighting - weighting function to use when blending frames. options are listed below:
- equal - each frame is blended equally
- gaussian
- gaussian_sym
- pyramid
- pyramid_sym
- custom weights - custom frame weights, e.g. [5, 3, 3, 2, 1]. higher numbers indicate frames being more visible when blending, lower numbers mean they are less so.
- custom function - generate weights based off of custom python code, which is called for each frame 'x', e.g. -x**2+1
- interpolate - whether or not the input video file will be interpolated to a higher fps
- interpolated fps - if interpolate is enabled, this is the fps that the input file will be interpolated to (before blending)
- quality - crf of the output video (qp if using GPU rendering)
- deduplicate - removes duplicate frames and generates new interpolated frames to take their place
- preview - opens a render preview window
- detailed filenames - adds blur settings to generated filenames
- input timescale - timescale of the input video file (will be sped up/slowed down accordingly)
- output timescale - timescale of the output video file
- adjust timescaled audio pitch - will pitch shift audio when sped up/slowed down
- brightness - brightness of the output video
- saturation - saturation of the output video
- contrast - contrast of the output video
- gpu interpolation - uses gpu when interpolating
- gpu rendering - uses gpu when rendering
- gpu type (nvidia/amd/intel) - your gpu type
- video container - the output video container
- custom ffmpeg filters - custom ffmpeg filters to be used when rendering (replaces gpu & quality options)
- debug - shows debug window, prints commands used by blur
- blur weighting gaussian std dev - standard deviation used in the gaussian weighting
- blur weighting triangle reverse - reverses the direction of the triangle weighting
- blur weighting bound - weighting bounds, spreads out weights more
-
interpolation preset - preset used for framerate interpolation, one of:
- weak (default) - explained further here
- film - explained further here
- smooth - explained further here
- default (default svp settings)
-
interpolation algorithm - algorithm used for framerate interpolation, one of:
- 13 - best overall quality and smoothness (default) - explained further here
- 23 - sometimes smoother than 13, but can result in smearing - explained further here
- 1 - explained further here
- 2 - explained further here
- 11 - explained further here
- 21 - explained further here
-
interpolation block size - block size used for framerate interpolation. higher block size = less accurate blur, will result in spaces around non-moving objects of the frame, also renders faster. lower block size = more accurate blur, but can result in artifacting, also slower. for higher framerate input videos lower block size can be better. options:
- 4
- 8 (default)
- 16
- 32
-
interpolation mask area - mask amount used when interpolating. higher values can mean static objects are blurred less, but can also result in less smooth output (moving parts of the image can be mistaken for static parts and don't get blurred)
You can customise the SVP interpolation settings even further by manually defining json parameters. see here for explanations on settings
- manual svp: enables manual svp settings, true/false
- super string: json string used as input in SVSuper
- vectors string: json string used as input in SVAnalyse
- smooth string: json string used as input in SVSmoothFps
these options are not visible by default, add them to your config and they will be used.
Most of the default settings are what I find work the best, but some settings can depend on your preferences.
For 60fps footage:
| intent | amount |
|---|---|
| Maximum blur/smoothness | >1 |
| Normal blur | 1 |
| Medium blur | 0.5 |
| Low blur | 0.2-0.3 |
To preserve your old blur amount when changing framerate use the following formula:
[new blur amount] = [old blur amount] × ([new fps] / [old fps])
So normal blur at 30fps becomes 0.5, etc.
Results can become worse if this is too high. In general I recommend around 5x the input fps. Also SVP seems to only be able to interpolate up to 10x the input fps, so don't bother trying anything higher than that.
Using blur on 60fps footage results in clean motion blur, but occasionally leaves some smearing artifacts. To remove these artifacts, higher framerate source footage can be used. Recording with software such as OBS at framerates like 120/180fps will result in a greatly reduced amount of artifacting.
If your footage contains duplicate frames then occasionally blurred frames will look out of place, making the video seem unsmooth at points. The 'deduplicate' option will automatically fill in duplicated frames with interpolated frames to prevent this from happening.
Blur supports rendering from frameservers. This means you can avoid having to run blur on your input videos when video editing. When rendering, simply output (make sure your project is high framerate) to the frameserver and then drag the generated AVI into blur. Note that some video editing software might limit the maximum project framerate.
Note: I don't suggest manual installation due to the large amount of dependencies. If possible, stick to using the provided installer.
- adjust
- akarin
- avisource (x64)
- libmvtools (x64)
- LSMASHSource (x64)
- SVPflow 4.2.0.142 (x64)
- blur plugins
- Download the latest release or build the project.
- Install Python
- Install FFmpeg and add it to PATH
- Install the 64-bit version of VapourSynth
- Install the required VapourSynth plugins