.
edgedetect
Detect and draw edges. The filter uses the Canny Edge Detection algorithm.
The filter accepts the following options:
low
high
Set low and high threshold values used by the Canny thresholding algorithm.
The high threshold selects the "strong" edge pixels, which are then connected through 8-connectivity
with the "weak" edge pixels selected by the low threshold.
low and high threshold values must be choosen in the range [0,1], and low should be lesser or equal
to high.
Default value for low is "20/255", and default value for high is "50/255".
Example:
edgedetect=low=0.1:high=0.4
extractplanes
Extract color channel components from input video stream into separate grayscale video streams.
The filter accepts the following option:
planes
Set plane(s) to extract.
Available values for planes are:
y
u
v
a
r
g
b
Choosing planes not available in the input will result in an error. That means you cannot select
"r", "g", "b" planes with "y", "u", "v" planes at same time.
Examples
· Extract luma, u and v color channel component from input video frame into 3 grayscale outputs:
ffmpeg -i video.avi -filter_complex 'extractplanes=y+u+v[y][u][v]' -map '[y]' y.avi -map '[u]' u.avi -map '[v]' v.avi
elbg
Apply a posterize effect using the ELBG (Enhanced LBG) algorithm.
For each input image, the filter will compute the optimal mapping from the input to the output given the
codebook length, that is the number of distinct output colors.
This filter accepts the following options.
codebook_length, l
Set codebook length. The value must be a positive integer, and represents the number of distinct
output colors. Default value is 256.
nb_steps, n
Set the maximum number of iterations to apply for computing the optimal mapping. The higher the value
the better the result and the higher the computation time. Default value is 1.
seed, s
Set a random seed, must be an integer included between 0 and UINT32_MAX. If not specified, or if
explicitly set to -1, the filter will try to use a good random seed on a best effort basis.
fade
Apply fade-in/out effect to input video.
This filter accepts the following options:
type, t
The effect type -- can be either "in" for fade-in, or "out" for a fade-out effect. Default is "in".
start_frame, s
Specify the number of the start frame for starting to apply the fade effect. Default is 0.
nb_frames, n
The number of frames for which the fade effect has to last. At the end of the fade-in effect the
output video will have the same intensity as the input video, at the end of the fade-out transition
the output video will be filled with the selected color. Default is 25.
alpha
If set to 1, fade only alpha channel, if one exists on the input. Default value is 0.
start_time, st
Specify the timestamp (in seconds) of the frame to start to apply the fade effect. If both
start_frame and start_time are specified, the fade will start at whichever comes last. Default is 0.
duration, d
The number of seconds for which the fade effect has to last. At the end of the fade-in effect the
output video will have the same intensity as the input video, at the end of the fade-out transition
the output video will be filled with the selected color. If both duration and nb_frames are
specified, duration is used. Default is 0.
color, c
Specify the color of the fade. Default is "black".
Examples
· Fade in first 30 frames of video:
fade=in:0:30
The command above is equivalent to:
fade=t=in:s=0:n=30
· Fade out last 45 frames of a 200-frame video:
fade=out:155:45
fade=type=out:start_frame=155:nb_frames=45
· Fade in first 25 frames and fade out last 25 frames of a 1000-frame video:
fade=in:0:25, fade=out:975:25
· Make first 5 frames yellow, then fade in from frame 5-24:
fade=in:5:20:color=yellow
· Fade in alpha over first 25 frames of video:
fade=in:0:25:alpha=1
· Make first 5.5 seconds black, then fade in for 0.5 seconds:
fade=t=in:st=5.5:d=0.5
field
Extract a single field from an interlaced image using stride arithmetic to avoid wasting CPU time. The
output frames are marked as non-interlaced.
The filter accepts the following options:
type
Specify whether to extract the top (if the value is 0 or "top") or the bottom field (if the value is
1 or "bottom").
fieldmatch
Field matching filter for inverse telecine. It is meant to reconstruct the progressive frames from a
telecined stream. The filter does not drop duplicated frames, so to achieve a complete inverse telecine
"fieldmatch" needs to be followed by a decimation filter such as decimate in the filtergraph.
The separation of the field matching and the decimation is notably motivated by the possibility of
inserting a de-interlacing filter fallback between the two. If the source has mixed telecined and real
interlaced content, "fieldmatch" will not be able to match fields for the interlaced parts. But these
remaining combed frames will be marked as interlaced, and thus can be de-interlaced by a later filter
such as yadif before decimation.
In addition to the various configuration options, "fieldmatch" can take an optional second stream,
activated through the ppsrc option. If enabled, the frames reconstruction will be based on the fields and
frames from this second stream. This allows the first input to be pre-processed in order to help the
various algorithms of the filter, while keeping the output lossless (assuming the fields are matched
properly). Typically, a field-aware denoiser, or brightness/contrast adjustments can help.
Note that this filter uses the same algorithms as TIVTC/TFM (AviSynth project) and VIVTC/VFM (VapourSynth
project). The later is a light clone of TFM from which "fieldmatch" is based on. While the semantic and
usage are very close, some behaviour and options names can differ.
The filter accepts the following options:
order
Specify the assumed field order of the input stream. Available values are:
auto
Auto detect parity (use FFmpeg's internal parity value).
bff Assume bottom field first.
tff Assume top field first.
Note that it is sometimes recommended not to trust the parity announced by the stream.
Default value is auto.
mode
Set the matching mode or strategy to use. pc mode is the safest in the sense that it won't risk
creating jerkiness due to duplicate frames when possible, but if there are bad edits or blended
fields it will end up outputting combed frames when a good match might actually exist. On the other
hand, pcn_ub mode is the most risky in terms of creating jerkiness, but will almost always find a
good frame if there is one. The other values are all somewhere in between pc and pcn_ub in terms of
risking jerkiness and creating duplicate frames versus finding good matches in sections with bad
edits, orphaned fields, blended fields, etc.
More details about p/c/n/u/b are available in p/c/n/u/b meaning section.
Available values are:
pc 2-way matching (p/c)
pc_n
2-way matching, and trying 3rd match if still combed (p/c + n)
pc_u
2-way matching, and trying 3rd match (same order) if still combed (p/c + u)
pc_n_ub
2-way matching, trying 3rd match if still combed, and trying 4th/5th matches if still combed (p/c
+ n + u/b)
pcn 3-way matching (p/c/n)
pcn_ub
3-way matching, and trying 4th/5th matches if all 3 of the original matches are detected as
combed (p/c/n + u/b)
The parenthesis at the end indicate the matches that would be used for that mode assuming order=tff
(and field on auto or top).
In terms of speed pc mode is by far the fastest and pcn_ub is the slowest.
Default value is pc_n.
ppsrc
Mark the main input stream as a pre-processed input, and enable the secondary input stream as the
clean source to pick the fields from. See the filter introduction for more details. It is similar to
the clip2 feature from VFM/TFM.
Default value is 0 (disabled).
field
Set the field to match from. It is recommended to set this to the same value as order unless you
experience matching failures with that setting. In certain circumstances changing the field that is
used to match from can have a large impact on matching performance. Available values are:
auto
Automatic (same value as order).
bottom
Match from the bottom field.
top Match from the top field.
Default value is auto.
mchroma
Set whether or not chroma is included during the match comparisons. In most cases it is recommended
to leave this enabled. You should set this to 0 only if your clip has bad chroma problems such as
heavy rainbowing or other artifacts. Setting this to 0 could also be used to speed things up at the
cost of some accuracy.
Default value is 1.
y0
y1 These define an exclusion band which excludes the lines between y0 and y1 from being included in the
field matching decision. An exclusion band can be used to ignore subtitles, a logo, or other things
that may interfere with the matching. y0 sets the starting scan line and y1 sets the ending line; all
lines in between y0 and y1 (including y0 and y1) will be ignored. Setting y0 and y1 to the same value
will disable the feature. y0 and y1 defaults to 0.
scthresh
Set the scene change detection threshold as a percentage of maximum change on the luma plane. Good
values are in the "[8.0, 14.0]" range. Scene change detection is only relevant in case combmatch=sc.
The range for scthresh is "[0.0, 100.0]".
Default value is 12.0.
combmatch
When combatch is not none, "fieldmatch" will take into account the combed scores of matches when
deciding what match to use as the final match. Available values are:
none
No final matching based on combed scores.
sc Combed scores are only used when a scene change is detected.
full
Use combed scores all the time.
Default is sc.
combdbg
Force "fieldmatch" to calculate the combed metrics for certain matches and print them. This setting
is known as micout in TFM/VFM vocabulary. Available values are:
none
No forced calculation.
pcn Force p/c/n calculations.
pcnub
Force p/c/n/u/b calculations.
Default value is none.
cthresh
This is the area combing threshold used for combed frame detection. This essentially controls how
"strong" or "visible" combing must be to be detected. Larger values mean combing must be more
visible and smaller values mean combing can be less visible or strong and still be detected. Valid
settings are from "-1" (every pixel will be detected as combed) to 255 (no pixel will be detected as
combed). This is basically a pixel difference value. A good range is "[8, 12]".
Default value is 9.
chroma
Sets whether or not chroma is considered in the combed frame decision. Only disable this if your
source has chroma problems (rainbowing, etc.) that are causing problems for the combed frame
detection with chroma enabled. Actually, using chroma=0 is usually more reliable, except for the case
where there is chroma only combing in the source.
Default value is 0.
blockx
blocky
Respectively set the x-axis and y-axis size of the window used during combed frame detection. This
has to do with the size of the area in which combpel pixels are required to be detected as combed for
a frame to be declared combed. See the combpel parameter description for more info. Possible values
are any number that is a power of 2 starting at 4 and going up to 512.
Default value is 16.
combpel
The number of combed pixels inside any of the blocky by blockx size blocks on the frame for the frame
to be detected as combed. While cthresh controls how "visible" the combing must be, this setting
controls "how much" combing there must be in any localized area (a window defined by the blockx and
blocky settings) on the frame. Minimum value is 0 and maximum is "blocky x blockx" (at which point no
frames will ever be detected as combed). This setting is known as MI in TFM/VFM vocabulary.
Default value is 80.
p/c/n/u/b meaning
p/c/n
We assume the following telecined stream:
Top fields: 1 2 2 3 4
Bottom fields: 1 2 3 4 4
The numbers correspond to the progressive frame the fields relate to. Here, the first two frames are
progressive, the 3rd and 4th are combed, and so on.
When "fieldmatch" is configured to run a matching from bottom (field=bottom) this is how this input
stream get transformed:
Input stream:
T 1 2 2 3 4
B 1 2 3 4 4 <-- matching reference
Matches: c c n n c
Output stream:
T 1 2 3 4 4
B 1 2 3 4 4
As a result of the field matching, we can see that some frames get duplicated. To perform a complete
inverse telecine, you need to rely on a decimation filter after this operation. See for instance the
decimate filter.
The same operation now matching from top fields (field=top) looks like this:
Input stream:
T 1 2 2 3 4 <-- matching reference
B 1 2 3 4 4
Matches: c c p p c
Output stream:
T 1 2 2 3 4
B 1 2 2 3 4
In these examples, we can see what p, c and n mean; basically, they refer to the frame and field of the
opposite parity:
*
*
*
u/b
The u and b matching are a bit special in the sense that they match from the opposite parity flag. In the
following examples, we assume that we are currently matching the 2nd frame (Top:2, bottom:2). According
to the match, a 'x' is placed above and below each matched fields.
With bottom matching (field=bottom):
Match: c p n b u
x x x x x
Top 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2
Bottom 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
x x x x x
Output frames:
2 1 2 2 2
2 2 2 1 3
With top matching (field=top):
Match: c p n b u
x x x x x
Top 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2
Bottom 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
x x x x x
Output frames:
2 2 2 1 2
2 1 3 2 2
Examples
Simple IVTC of a top field first telecined stream:
fieldmatch=order=tff:combmatch=none, decimate
Advanced IVTC, with fallback on yadif for still combed frames:
fieldmatch=order=tff:combmatch=full, yadif=deint=interlaced, decimate
fieldorder
Transform the field order of the input video.
This filter accepts the following options:
order
Output field order. Valid values are tff for top field first or bff for bottom field first.
Default value is tff.
Transformation is achieved by shifting the picture content up or down by one line, and filling the
remaining line with appropriate picture content. This method is consistent with most broadcast field
order converters.
If the input video is not flagged as being interlaced, or it is already flagged as being of the required
output field order then this filter does not alter the incoming video.
This filter is very useful when converting to or from PAL DV material, which is bottom field first.
For example:
ffmpeg -i in.vob -vf "fieldorder=bff" out.dv
fifo
Buffer input images and send them when they are requested.
This filter is mainly useful when auto-inserted by the libavfilter framework.
The filter does not take parameters.
format
Convert the input video to one of the specified pixel formats. Libavfilter will try to pick one that is
supported for the input to the next filter.
This filter accepts the following parameters:
pix_fmts
A '|'-separated list of pixel format names, for example "pix_fmts=yuv420p|monow|rgb24".
Examples
· Convert the input video to the format yuv420p
format=pix_fmts=yuv420p
Convert the input video to any of the formats in the list
format=pix_fmts=yuv420p|yuv444p|yuv410p
fps
Convert the video to specified constant frame rate by duplicating or dropping frames as necessary.
This filter accepts the following named parameters:
fps Desired output frame rate. The default is 25.
round
Rounding method.
Possible values are:
zero
zero round towards 0
inf round away from 0
down
round towards -infinity
up round towards +infinity
near
round to nearest
The default is "near".
start_time
Assume the first PTS should be the given value, in seconds. This allows for padding/trimming at the
start of stream. By default, no assumption is made about the first frame's expected PTS, so no
padding or trimming is done. For example, this could be set to 0 to pad the beginning with
duplicates of the first frame if a video stream starts after the audio stream or to trim any frames
with a negative PTS.
Alternatively, the options can be specified as a flat string: fps[:round].
See also the setpts filter.
Examples
· A typical usage in order to set the fps to 25:
fps=fps=25
· Sets the fps to 24, using abbreviation and rounding method to round to nearest:
fps=fps=film:round=near
framepack
Pack two different video streams into a stereoscopic video, setting proper metadata on supported codecs.
The two views should have the same size and framerate and processing will stop when the shorter video
ends. Please note that you may conveniently adjust view properties with the scale and fps filters.
This filter accepts the following named parameters:
format
Desired packing format. Supported values are:
sbs Views are next to each other (default).
tab Views are on top of each other.
lines
Views are packed by line.
columns
Views are eacked by column.
frameseq
Views are temporally interleaved.
Some examples follow:
# Convert left and right views into a frame sequential video.
ffmpeg -i LEFT -i RIGHT -filter_complex framepack=frameseq OUTPUT
# Convert views into a side-by-side video with the same output resolution as the input.
ffmpeg -i LEFT -i RIGHT -filter_complex [0:v]scale=w=iw/2[left],[1:v]scale=w=iw/2[right],[left][right]framepack=sbs OUTPUT
framestep
Select one frame every N-th frame.
This filter accepts the following option:
step
Select frame after every "step" frames. Allowed values are positive integers higher than 0. Default
value is 1.
frei0r
Apply a frei0r effect to the input video.
To enable compilation of this filter you need to install the frei0r header and configure FFmpeg with
"--enable-frei0r".
This filter accepts the following options:
filter_name
The name to the frei0r effect to load. If the environment variable FREI0R_PATH is defined, the frei0r
effect is searched in each one of the directories specified by the colon separated list in
FREIOR_PATH, otherwise in the standard frei0r paths, which are in this order: HOME/.frei0r-1/lib/,
/usr/local/lib/frei0r-1/, /usr/lib/frei0r-1/.
filter_params
A '|'-separated list of parameters to pass to the frei0r effect.
A frei0r effect parameter can be a boolean (whose values are specified with "y" and "n"), a double, a
color (specified by the syntax R/G/B, (R, G, and B being float numbers from 0.0 to 1.0) or by a color
description specified in the "Color" section in the ffmpeg-utils manual), a position (specified by the
syntax X/Y, X and Y being float numbers) and a string.
The number and kind of parameters depend on the loaded effect. If an effect parameter is not specified
the default value is set.
Examples
· Apply the distort0r effect, set the first two double parameters:
frei0r=filter_name=distort0r:filter_params=0.5|0.01
· Apply the colordistance effect, take a color as first parameter:
frei0r=colordistance:0.2/0.3/0.4
frei0r=colordistance:violet
frei0r=colordistance:0x112233
· Apply the perspective effect, specify the top left and top right image positions:
frei0r=perspective:0.2/0.2|0.8/0.2
For more information see:
geq
The filter accepts the following options:
lum_expr, lum
Set the luminance expression.
cb_expr, cb
Set the chrominance blue expression.
cr_expr, cr
Set the chrominance red expression.
alpha_expr, a
Set the alpha expression.
red_expr, r
Set the red expression.
green_expr, g
Set the green expression.
blue_expr, b
Set the blue expression.
The colorspace is selected according to the specified options. If one of the lum_expr, cb_expr, or
cr_expr options is specified, the filter will automatically select a YCbCr colorspace. If one of the
red_expr, green_expr, or blue_expr options is specified, it will select an RGB colorspace.
If one of the chrominance expression is not defined, it falls back on the other one. If no alpha
expression is specified it will evaluate to opaque value. If none of chrominance expressions are
specified, they will evaluate to the luminance expression.
The expressions can use the following variables and functions:
N The sequential number of the filtered frame, starting from 0.
X
Y The coordinates of the current sample.
W
H The width and height of the image.
SW
SH Width and height scale depending on the currently filtered plane. It is the ratio between the
corresponding luma plane number of pixels and the current plane ones. E.g. for YUV4:2:0 the values
are "1,1" for the luma plane, and "0.5,0.5" for chroma planes.
T Time of the current frame, expressed in seconds.
p(x, y)
Return the value of the pixel at location (x,y) of the current plane.
lum(x, y)
Return the value of the pixel at location (x,y) of the luminance plane.
cb(x, y)
Return the value of the pixel at location (x,y) of the blue-difference chroma plane. Return 0 if
there is no such plane.
cr(x, y)
Return the value of the pixel at location (x,y) of the red-difference chroma plane. Return 0 if there
is no such plane.
r(x, y)
g(x, y)
b(x, y)
Return the value of the pixel at location (x,y) of the red/green/blue component. Return 0 if there is
no such component.
alpha(x, y)
Return the value of the pixel at location (x,y) of the alpha plane. Return 0 if there is no such
plane.
For functions, if x and y are outside the area, the value will be automatically clipped to the closer
edge.
Examples
· Flip the image horizontally:
geq=p(W-X\,Y)
· Generate a bidimensional sine wave, with angle "PI/3" and a wavelength of 100 pixels:
geq=128 + 100*sin(2*(PI/100)*(cos(PI/3)*(X-50*T) + sin(PI/3)*Y)):128:128
· Generate a fancy enigmatic moving light:
nullsrc=s=256x256,geq=random(1)/hypot(X-cos(N*0.07)*W/2-W/2\,Y-sin(N*0.09)*H/2-H/2)^2*1000000*sin(N*0.02):128:128
· Generate a quick emboss effect:
format=gray,geq=lum_expr='(p(X,Y)+(256-p(X-4,Y-4)))/2'
· Modify RGB components depending on pixel position:
geq=r='X/W*r(X,Y)':g='(1-X/W)*g(X,Y)':b='(H-Y)/H*b(X,Y)'
gradfun
Fix the banding artifacts that are sometimes introduced into nearly flat regions by truncation to 8bit
color depth. Interpolate the gradients that should go where the bands are, and dither them.
This filter is designed for playback only. Do not use it prior to lossy compression, because compression
tends to lose the dither and bring back the bands.
This filter accepts the following options:
strength
The maximum amount by which the filter will change any one pixel. Also the threshold for detecting
nearly flat regions. Acceptable values range from .51 to 64, default value is 1.2, out-of-range
values will be clipped to the valid range.
radius
The neighborhood to fit the gradient to. A larger radius makes for smoother gradients, but also
prevents the filter from modifying the pixels near detailed regions. Acceptable values are 8-32,
default value is 16, out-of-range values will be clipped to the valid range.
Alternatively, the options can be specified as a flat string: strength[:radius]
Examples
· Apply the filter with a 3.5 strength and radius of 8:
gradfun=3.5:8
· Specify radius, omitting the strength (which will fall-back to the default value):
gradfun=radius=8
haldclut
Apply a Hald CLUT to a video stream.
First input is the video stream to process, and second one is the Hald CLUT. The Hald CLUT input can be
a simple picture or a complete video stream.
The filter accepts the following options:
shortest
Force termination when the shortest input terminates. Default is 0.
repeatlast
Continue applying the last CLUT after the end of the stream. A value of 0 disable the filter after
the last frame of the CLUT is reached. Default is 1.
"haldclut" also has the same interpolation options as lut3d (both filters share the same internals).
More information about the Hald CLUT can be found on Eskil Steenberg's website (Hald CLUT author) at
.
Workflow examples
Hald CLUT video stream
Generate an identity Hald CLUT stream altered with various effects:
ffmpeg -f lavfi -i B=8 -vf "hue=H=2*PI*t:s=sin(2*PI*t)+1, curves=cross_process" -t 10 -c:v ffv1 clut.nut
Note: make sure you use a lossless codec.
Then use it with "haldclut" to apply it on some random stream:
ffmpeg -f lavfi -i mandelbrot -i clut.nut -filter_complex '[0][1] haldclut' -t 20 mandelclut.mkv
The Hald CLUT will be applied to the 10 first seconds (duration of clut.nut), then the latest picture of
that CLUT stream will be applied to the remaining frames of the "mandelbrot" stream.
Hald CLUT with preview
A Hald CLUT is supposed to be a squared image of "Level*Level*Level" by "Level*Level*Level" pixels. For a
given Hald CLUT, FFmpeg will select the biggest possible square starting at the top left of the picture.
The remaining padding pixels (bottom or right) will be ignored. This area can be used to add a preview of
the Hald CLUT.
Typically, the following generated Hald CLUT will be supported by the "haldclut" filter:
ffmpeg -f lavfi -i B=8 -vf "
pad=iw+320 [padded_clut];
smptebars=s=320x256, split [a][b];
[padded_clut][a] overlay=W-320:h, curves=color_negative [main];
[main][b] overlay=W-320" -frames:v 1 clut.png
It contains the original and a preview of the effect of the CLUT: SMPTE color bars are displayed on the
right-top, and below the same color bars processed by the color changes.
Then, the effect of this Hald CLUT can be visualized with:
ffplay input.mkv -vf "movie=clut.png, [in] haldclut"
hflip
Flip the input video horizontally.
For example to horizontally flip the input video with ffmpeg:
ffmpeg -i in.avi -vf "hflip" out.avi
histeq
This filter applies a global color histogram equalization on a per-frame basis.
It can be used to correct video that has a compressed range of pixel intensities. The filter
redistributes the pixel intensities to equalize their distribution across the intensity range. It may be
viewed as an "automatically adjusting contrast filter". This filter is useful only for correcting
degraded or poorly captured source video.
The filter accepts the following options:
strength
Determine the amount of equalization to be applied. As the strength is reduced, the distribution of
pixel intensities more-and-more approaches that of the input frame. The value must be a float number
in the range [0,1] and defaults to 0.200.
intensity
Set the maximum intensity that can generated and scale the output values appropriately. The strength
should be set as desired and then the intensity can be limited if needed to avoid washing-out. The
value must be a float number in the range [0,1] and defaults to 0.210.
antibanding
Set the antibanding level. If enabled the filter will randomly vary the luminance of output pixels by
a small amount to avoid banding of the histogram. Possible values are "none", "weak" or "strong". It
defaults to "none".
histogram
Compute and draw a color distribution histogram for the input video.
The computed histogram is a representation of the color component distribution in an image.
The filter accepts the following options:
mode
Set histogram mode.
It accepts the following values:
levels
Standard histogram that displays the color components distribution in an image. Displays color
graph for each color component. Shows distribution of the Y, U, V, A or R, G, B components,
depending on input format, in the current frame. Below each graph a color component scale meter
is shown.
color
Displays chroma values (U/V color placement) in a two dimensional graph (which is called a
vectorscope). The brighter a pixel in the vectorscope, the more pixels of the input frame
correspond to that pixel (i.e., more pixels have this chroma value). The V component is displayed
on the horizontal (X) axis, with the leftmost side being V = 0 and the rightmost side being V =
255. The U component is displayed on the vertical (Y) axis, with the top representing U = 0 and
the bottom representing U = 255.
The position of a white pixel in the graph corresponds to the chroma value of a pixel of the
input clip. The graph can therefore be used to read the hue (color flavor) and the saturation
(the dominance of the hue in the color). As the hue of a color changes, it moves around the
square. At the center of the square the saturation is zero, which means that the corresponding
pixel has no color. If the amount of a specific color is increased (while leaving the other
colors unchanged) the saturation increases, and the indicator moves towards the edge of the
square.
color2
Chroma values in vectorscope, similar as "color" but actual chroma values are displayed.
waveform
Per row/column color component graph. In row mode, the graph on the left side represents color
component value 0 and the right side represents value = 255. In column mode, the top side
represents color component value = 0 and bottom side represents value = 255.
Default value is "levels".
level_height
Set height of level in "levels". Default value is 200. Allowed range is [50, 2048].
scale_height
Set height of color scale in "levels". Default value is 12. Allowed range is [0, 40].
step
Set step for "waveform" mode. Smaller values are useful to find out how many values of the same
luminance are distributed across input rows/columns. Default value is 10. Allowed range is [1, 255].
waveform_mode
Set mode for "waveform". Can be either "row", or "column". Default is "row".
waveform_mirror
Set mirroring mode for "waveform". 0 means unmirrored, 1 means mirrored. In mirrored mode, higher
values will be represented on the left side for "row" mode and at the top for "column" mode. Default
is 0 (unmirrored).
display_mode
Set display mode for "waveform" and "levels". It accepts the following values:
parade
Display separate graph for the color components side by side in "row" waveform mode or one below
the other in "column" waveform mode for "waveform" histogram mode. For "levels" histogram mode,
per color component graphs are placed below each other.
Using this display mode in "waveform" histogram mode makes it easy to spot color casts in the
highlights and shadows of an image, by comparing the contours of the top and the bottom graphs of
each waveform. Since whites, grays, and blacks are characterized by exactly equal amounts of red,
green, and blue, neutral areas of the picture should display three waveforms of roughly equal
width/height. If not, the correction is easy to perform by making level adjustments the three
waveforms.
overlay
Presents information identical to that in the "parade", except that the graphs representing color
components are superimposed directly over one another.
This display mode in "waveform" histogram mode makes it easier to spot relative differences or
similarities in overlapping areas of the color components that are supposed to be identical, such
as neutral whites, grays, or blacks.
Default is "parade".
levels_mode
Set mode for "levels". Can be either "linear", or "logarithmic". Default is "linear".
Examples
· Calculate and draw histogram:
ffplay -i input -vf histogram
hqdn3d
High precision/quality 3d denoise filter. This filter aims to reduce image noise producing smooth images
and making still images really still. It should enhance compressibility.
It accepts the following optional parameters:
luma_spatial
a non-negative float number which specifies spatial luma strength, defaults to 4.0
chroma_spatial
a non-negative float number which specifies spatial chroma strength, defaults to 3.0*luma_spatial/4.0
luma_tmp
a float number which specifies luma temporal strength, defaults to 6.0*luma_spatial/4.0
chroma_tmp
a float number which specifies chroma temporal strength, defaults to
luma_tmp*chroma_spatial/luma_spatial
hue
Modify the hue and/or the saturation of the input.
This filter accepts the following options:
h Specify the hue angle as a number of degrees. It accepts an expression, and defaults to "0".
s Specify the saturation in the [-10,10] range. It accepts an expression and defaults to "1".
H Specify the hue angle as a number of radians. It accepts an expression, and defaults to "0".
b Specify the brightness in the [-10,10] range. It accepts an expression and defaults to "0".
h and H are mutually exclusive, and can't be specified at the same time.
The b, h, H and s option values are expressions containing the following constants:
n frame count of the input frame starting from 0
pts presentation timestamp of the input frame expressed in time base units
r frame rate of the input video, NAN if the input frame rate is unknown
t timestamp expressed in seconds, NAN if the input timestamp is unknown
tb time base of the input video
Examples
· Set the hue to 90 degrees and the saturation to 1.0:
hue=h=90:s=1
· Same command but expressing the hue in radians:
hue=H=PI/2:s=1
· Rotate hue and make the saturation swing between 0 and 2 over a period of 1 second:
hue="H=2*PI*t: s=sin(2*PI*t)+1"
· Apply a 3 seconds saturation fade-in effect starting at 0:
hue="s=min(t/3\,1)"
The general fade-in expression can be written as:
hue="s=min(0\, max((t-START)/DURATION\, 1))"
· Apply a 3 seconds saturation fade-out effect starting at 5 seconds:
hue="s=max(0\, min(1\, (8-t)/3))"
The general fade-out expression can be written as:
hue="s=max(0\, min(1\, (START+DURATION-t)/DURATION))"
Commands
This filter supports the following commands:
b
s
h
H Modify the hue and/or the saturation and/or brightness of the input video. The command accepts the
same syntax of the corresponding option.
If the specified expression is not valid, it is kept at its current value.
idet
Detect video interlacing type.
This filter tries to detect if the input is interlaced or progressive, top or bottom field first.
The filter accepts the following options:
intl_thres
Set interlacing threshold.
prog_thres
Set progressive threshold.
il
Deinterleave or interleave fields.
This filter allows to process interlaced images fields without deinterlacing them. Deinterleaving splits
the input frame into 2 fields (so called half pictures). Odd lines are moved to the top half of the
output image, even lines to the bottom half. You can process (filter) them independently and then re-
interleave them.
The filter accepts the following options:
luma_mode, l
chroma_mode, c
alpha_mode, a
Available values for luma_mode, chroma_mode and alpha_mode are:
none
Do nothing.
deinterleave, d
Deinterleave fields, placing one above the other.
interleave, i
Interleave fields. Reverse the effect of deinterleaving.
Default value is "none".
luma_swap, ls
chroma_swap, cs
alpha_swap, as
Swap luma/chroma/alpha fields. Exchange even & odd lines. Default value is 0.
interlace
Simple interlacing filter from progressive contents. This interleaves upper (or lower) lines from odd
frames with lower (or upper) lines from even frames, halving the frame rate and preserving image height.
A vertical lowpass filter is always applied in order to avoid twitter effects and reduce moire patterns.
Original Original New Frame
Frame 'j' Frame 'j+1' (tff)
========== =========== ==================
Line 0 --------------------> Frame 'j' Line 0
Line 1 Line 1 ----> Frame 'j+1' Line 1
Line 2 ---------------------> Frame 'j' Line 2
Line 3 Line 3 ----> Frame 'j+1' Line 3
... ... ...
New Frame + 1 will be generated by Frame 'j+2' and Frame 'j+3' and so on
It accepts the following optional parameters:
scan
determines whether the interlaced frame is taken from the even (tff - default) or odd (bff) lines of
the progressive frame.
kerndeint
Deinterlace input video by applying Donald Graft's adaptive kernel deinterling. Work on interlaced parts
of a video to produce progressive frames.
The description of the accepted parameters follows.
thresh
Set the threshold which affects the filter's tolerance when determining if a pixel line must be
processed. It must be an integer in the range [0,255] and defaults to 10. A value of 0 will result in
applying the process on every pixels.
map Paint pixels exceeding the threshold value to white if set to 1. Default is 0.
order
Set the fields order. Swap fields if set to 1, leave fields alone if 0. Default is 0.
sharp
Enable additional sharpening if set to 1. Default is 0.
twoway
Enable twoway sharpening if set to 1. Default is 0.
Examples
· Apply default values:
kerndeint=thresh=10:map=0:order=0:sharp=0:twoway=0
· Enable additional sharpening:
kerndeint=sharp=1
· Paint processed pixels in white:
kerndeint=map=1
lut3d
Apply a 3D LUT to an input video.
The filter accepts the following options:
file
Set the 3D LUT file name.
Currently supported formats:
3dl AfterEffects
cube
Iridas
dat DaVinci
m3d Pandora
interp
Select interpolation mode.
Available values are:
nearest
Use values from the nearest defined point.
trilinear
Interpolate values using the 8 points defining a cube.
tetrahedral
Interpolate values using a tetrahedron.
lut, lutrgb, lutyuv
Compute a look-up table for binding each pixel component input value to an output value, and apply it to
input video.
lutyuv applies a lookup table to a YUV input video, lutrgb to an RGB input video.
These filters accept the following options:
c0 set first pixel component expression
c1 set second pixel component expression
c2 set third pixel component expression
c3 set fourth pixel component expression, corresponds to the alpha component
r set red component expression
g set green component expression
b set blue component expression
a alpha component expression
y set Y/luminance component expression
u set U/Cb component expression
v set V/Cr component expression
Each of them specifies the expression to use for computing the lookup table for the corresponding pixel
component values.
The exact component associated to each of the c* options depends on the format in input.
The lut filter requires either YUV or RGB pixel formats in input, lutrgb requires RGB pixel formats in
input, and lutyuv requires YUV.
The expressions can contain the following constants and functions:
w
h the input width and height
val input value for the pixel component
clipval
the input value clipped in the minval-maxval range
maxval
maximum value for the pixel component
minval
minimum value for the pixel component
negval
the negated value for the pixel component value clipped in the minval-maxval range , it corresponds
to the expression "maxval-clipval+minval"
clip(val)
the computed value in val clipped in the minval-maxval range
gammaval(gamma)
the computed gamma correction value of the pixel component value clipped in the minval-maxval range,
corresponds to the expression "pow((clipval-minval)/(maxval-minval)\,gamma)*(maxval-minval)+minval"
All expressions default to "val".
Examples
· Negate input video:
lutrgb="r=maxval+minval-val:g=maxval+minval-val:b=maxval+minval-val"
lutyuv="y=maxval+minval-val:u=maxval+minval-val:v=maxval+minval-val"
The above is the same as:
lutrgb="r=negval:g=negval:b=negval"
lutyuv="y=negval:u=negval:v=negval"
· Negate luminance:
lutyuv=y=negval
· Remove chroma components, turns the video into a graytone image:
lutyuv="u=128:v=128"
· Apply a luma burning effect:
lutyuv="y=2*val"
· Remove green and blue components:
lutrgb="g=0:b=0"
· Set a constant alpha channel value on input:
format=rgba,lutrgb=a="maxval-minval/2"
· Correct luminance gamma by a 0.5 factor:
lutyuv=y=gammaval(0.5)
· Discard least significant bits of luma:
lutyuv=y='bitand(val, 128+64+32)'
mergeplanes
Merge color channel components from several video streams.
The filter accepts up to 4 input streams, and merge selected input planes to the output video.
This filter accepts the following options:
mapping
Set input to output plane mapping. Default is 0.
The mappings is specified as a bitmap. It should be specified as a hexadecimal number in the form
0xAa[Bb[Cc[Dd]]]. 'Aa' describes the mapping for the first plane of the output stream. 'A' sets the
number of the input stream to use (from 0 to 3), and 'a' the plane number of the corresponding input
to use (from 0 to 3). The rest of the mappings is similar, 'Bb' describes the mapping for the output
stream second plane, 'Cc' describes the mapping for the output stream third plane and 'Dd' describes
the mapping for the output stream fourth plane.
format
Set output pixel format. Default is "yuva444p".
Examples
· Merge three gray video streams of same width and height into single video stream:
[a0][a1][a2]mergeplanes=0x001020:yuv444p
· Merge 1st yuv444p stream and 2nd gray video stream into yuva444p video stream:
[a0][a1]mergeplanes=0x00010210:yuva444p
· Swap Y and A plane in yuva444p stream:
format=yuva444p,mergeplanes=0x03010200:yuva444p
· Swap U and V plane in yuv420p stream:
format=yuv420p,mergeplanes=0x000201:yuv420p
· Cast a rgb24 clip to yuv444p:
format=rgb24,mergeplanes=0x000102:yuv444p
mcdeint
Apply motion-compensation deinterlacing.
It needs one field per frame as input and must thus be used together with yadif=1/3 or equivalent.
This filter accepts the following options:
mode
Set the deinterlacing mode.
It accepts one of the following values:
fast
medium
slow
use iterative motion estimation
extra_slow
like slow, but use multiple reference frames.
Default value is fast.
parity
Set the picture field parity assumed for the input video. It must be one of the following values:
0, tff
assume top field first
1, bff
assume bottom field first
Default value is bff.
qp Set per-block quantization parameter (QP) used by the internal encoder.
Higher values should result in a smoother motion vector field but less optimal individual vectors.
Default value is 1.
mp
Apply an MPlayer filter to the input video.
This filter provides a wrapper around some of the filters of MPlayer/MEncoder.
This wrapper is considered experimental. Some of the wrapped filters may not work properly and we may
drop support for them, as they will be implemented natively into FFmpeg. Thus you should avoid depending
on them when writing portable scripts.
The filter accepts the parameters: filter_name[:=]filter_params
filter_name is the name of a supported MPlayer filter, filter_params is a string containing the
parameters accepted by the named filter.
The list of the currently supported filters follows:
eq2
eq
fspp
ilpack
pp7
softpulldown
uspp
The parameter syntax and behavior for the listed filters are the same of the corresponding MPlayer
filters. For detailed instructions check the "VIDEO FILTERS" section in the MPlayer manual.
Examples
· Adjust gamma, brightness, contrast:
mp=eq2=1.0:2:0.5
See also mplayer(1), .
mpdecimate
Drop frames that do not differ greatly from the previous frame in order to reduce frame rate.
The main use of this filter is for very-low-bitrate encoding (e.g. streaming over dialup modem), but it
could in theory be used for fixing movies that were inverse-telecined incorrectly.
A description of the accepted options follows.
max Set the maximum number of consecutive frames which can be dropped (if positive), or the minimum
interval between dropped frames (if negative). If the value is 0, the frame is dropped unregarding
the number of previous sequentially dropped frames.
Default value is 0.
hi
lo
frac
Set the dropping threshold values.
Values for hi and lo are for 8x8 pixel blocks and represent actual pixel value differences, so a
threshold of 64 corresponds to 1 unit of difference for each pixel, or the same spread out
differently over the block.
A frame is a candidate for dropping if no 8x8 blocks differ by more than a threshold of hi, and if no
more than frac blocks (1 meaning the whole image) differ by more than a threshold of lo.
Default value for hi is 64*12, default value for lo is 64*5, and default value for frac is 0.33.
negate
Negate input video.
This filter accepts an integer in input, if non-zero it negates the alpha component (if available). The
default value in input is 0.
noformat
Force libavfilter not to use any of the specified pixel formats for the input to the next filter.
This filter accepts the following parameters:
pix_fmts
A '|'-separated list of pixel format names, for example "pix_fmts=yuv420p|monow|rgb24".
Examples
· Force libavfilter to use a format different from yuv420p for the input to the vflip filter:
noformat=pix_fmts=yuv420p,vflip
· Convert the input video to any of the formats not contained in the list:
noformat=yuv420p|yuv444p|yuv410p
noise
Add noise on video input frame.
The filter accepts the following options:
all_seed
c0_seed
c1_seed
c2_seed
c3_seed
Set noise seed for specific pixel component or all pixel components in case of all_seed. Default
value is 123457.
all_strength, alls
c0_strength, c0s
c1_strength, c1s
c2_strength, c2s
c3_strength, c3s
Set noise strength for specific pixel component or all pixel components in case all_strength. Default
value is 0. Allowed range is [0, 100].
all_flags, allf
c0_flags, c0f
c1_flags, c1f
c2_flags, c2f
c3_flags, c3f
Set pixel component flags or set flags for all components if all_flags. Available values for
component flags are:
a averaged temporal noise (smoother)
p mix random noise with a (semi)regular pattern
t temporal noise (noise pattern changes between frames)
u uniform noise (gaussian otherwise)
Examples
Add temporal and uniform noise to input video:
noise=alls=20:allf=t+u
null
Pass the video source unchanged to the output.
ocv
Apply video transform using libopencv.
To enable this filter install libopencv library and headers and configure FFmpeg with
"--enable-libopencv".
This filter accepts the following parameters:
filter_name
The name of the libopencv filter to apply.
filter_params
The parameters to pass to the libopencv filter. If not specified the default values are assumed.
Refer to the official libopencv documentation for more precise information:
Follows the list of supported libopencv filters.
dilate
Dilate an image by using a specific structuring element. This filter corresponds to the libopencv
function "cvDilate".
It accepts the parameters: struct_el|nb_iterations.
struct_el represents a structuring element, and has the syntax: colsxrows+anchor_xxanchor_y/shape
cols and rows represent the number of columns and rows of the structuring element, anchor_x and anchor_y
the anchor point, and shape the shape for the structuring element, and can be one of the values "rect",
"cross", "ellipse", "custom".
If the value for shape is "custom", it must be followed by a string of the form "=filename". The file
with name filename is assumed to represent a binary image, with each printable character corresponding to
a bright pixel. When a custom shape is used, cols and rows are ignored, the number or columns and rows of
the read file are assumed instead.
The default value for struct_el is "3x3+0x0/rect".
nb_iterations specifies the number of times the transform is applied to the image, and defaults to 1.
Follow some example:
# use the default values
ocv=dilate
# dilate using a structuring element with a 5x5 cross, iterate two times
ocv=filter_name=dilate:filter_params=5x5+2x2/cross|2
# read the shape from the file diamond.shape, iterate two times
# the file diamond.shape may contain a pattern of characters like this:
# *
# ***
# *****
# ***
# *
# the specified cols and rows are ignored (but not the anchor point coordinates)
ocv=dilate:0x0+2x2/custom=diamond.shape|2
erode
Erode an image by using a specific structuring element. This filter corresponds to the libopencv
function "cvErode".
The filter accepts the parameters: struct_el:nb_iterations, with the same syntax and semantics as the
dilate filter.
smooth
Smooth the input video.
The filter takes the following parameters: type|param1|param2|param3|param4.
type is the type of smooth filter to apply, and can be one of the following values: "blur",
"blur_no_scale", "median", "gaussian", "bilateral". The default value is "gaussian".
param1, param2, param3, and param4 are parameters whose meanings depend on smooth type. param1 and param2
accept integer positive values or 0, param3 and param4 accept float values.
The default value for param1 is 3, the default value for the other parameters is 0.
These parameters correspond to the parameters assigned to the libopencv function "cvSmooth".
overlay
Overlay one video on top of another.
It takes two inputs and one output, the first input is the "main" video on which the second input is
overlayed.
This filter accepts the following parameters:
A description of the accepted options follows.
x
y Set the expression for the x and y coordinates of the overlayed video on the main video. Default
value is "0" for both expressions. In case the expression is invalid, it is set to a huge value
(meaning that the overlay will not be displayed within the output visible area).
eof_action
The action to take when EOF is encountered on the secondary input, accepts one of the following
values:
repeat
repeat the last frame (the default)
endall
end both streams
pass
pass through the main input
eval
Set when the expressions for x, and y are evaluated.
It accepts the following values:
init
only evaluate expressions once during the filter initialization or when a command is processed
frame
evaluate expressions for each incoming frame
Default value is frame.
shortest
If set to 1, force the output to terminate when the shortest input terminates. Default value is 0.
format
Set the format for the output video.
It accepts the following values:
yuv420
force YUV420 output
yuv422
force YUV422 output
yuv444
force YUV444 output
rgb force RGB output
Default value is yuv420.
rgb (deprecated)
If set to 1, force the filter to accept inputs in the RGB color space. Default value is 0. This
option is deprecated, use format instead.
repeatlast
If set to 1, force the filter to draw the last overlay frame over the main input until the end of the
stream. A value of 0 disables this behavior. Default value is 1.
The x, and y expressions can contain the following parameters.
main_w, W
main_h, H
main input width and height
overlay_w, w
overlay_h, h
overlay input width and height
x
y the computed values for x and y. They are evaluated for each new frame.
hsub
vsub
horizontal and vertical chroma subsample values of the output format. For example for the pixel
format "yuv422p" hsub is 2 and vsub is 1.
n the number of input frame, starting from 0
pos the position in the file of the input frame, NAN if unknown
t timestamp expressed in seconds, NAN if the input timestamp is unknown
Note that the n, pos, t variables are available only when evaluation is done per frame, and will evaluate
to NAN when eval is set to init.
Be aware that frames are taken from each input video in timestamp order, hence, if their initial
timestamps differ, it is a good idea to pass the two inputs through a setpts=PTS-STARTPTS filter to have
them begin in the same zero timestamp, as it does the example for the movie filter.
You can chain together more overlays but you should test the efficiency of such approach.
Commands
This filter supports the following commands:
x
y Modify the x and y of the overlay input. The command accepts the same syntax of the corresponding
option.
If the specified expression is not valid, it is kept at its current value.
Examples
· Draw the overlay at 10 pixels from the bottom right corner of the main video:
overlay=main_w-overlay_w-10:main_h-overlay_h-10
Using named options the example above becomes:
overlay=x=main_w-overlay_w-10:y=main_h-overlay_h-10
· Insert a transparent PNG logo in the bottom left corner of the input, using the ffmpeg tool with the
"-filter_complex" option:
ffmpeg -i input -i logo -filter_complex 'overlay=10:main_h-overlay_h-10' output
· Insert 2 different transparent PNG logos (second logo on bottom right corner) using the ffmpeg tool:
ffmpeg -i input -i logo1 -i logo2 -filter_complex 'overlay=x=10:y=H-h-10,overlay=x=W-w-10:y=H-h-10' output
· Add a transparent color layer on top of the main video, "WxH" must specify the size of the main input
to the overlay filter:
color=color=red@.3:size=WxH [over]; [in][over] overlay [out]
· Play an original video and a filtered version (here with the deshake filter) side by side using the
ffplay tool:
ffplay input.avi -vf 'split[a][b]; [a]pad=iw*2:ih[src]; [b]deshake[filt]; [src][filt]overlay=w'
The above command is the same as:
ffplay input.avi -vf 'split[b], pad=iw*2[src], [b]deshake, [src]overlay=w'
· Make a sliding overlay appearing from the left to the right top part of the screen starting since
time 2:
overlay=x='if(gte(t,2), -w+(t-2)*20, NAN)':y=0
· Compose output by putting two input videos side to side:
ffmpeg -i left.avi -i right.avi -filter_complex "
nullsrc=size=200x100 [background];
[0:v] setpts=PTS-STARTPTS, scale=100x100 [left];
[1:v] setpts=PTS-STARTPTS, scale=100x100 [right];
[background][left] overlay=shortest=1 [background+left];
[background+left][right] overlay=shortest=1:x=100 [left+right]
"
· mask 10-20 seconds of a video by applying the delogo filter to a section
ffmpeg -i test.avi -codec:v:0 wmv2 -ar 11025 -b:v 9000k
-vf '[in]split[split_main][split_delogo];[split_delogo]trim=start=360:end=371,delogo=0:0:640:480[delogoed];[split_main][delogoed]overlay=eof_action=pass[out]'
masked.avi
· Chain several overlays in cascade:
nullsrc=s=200x200 [bg];
testsrc=s=100x100, split=4 [in0][in1][in2][in3];
[in0] lutrgb=r=0, [bg] overlay=0:0 [mid0];
[in1] lutrgb=g=0, [mid0] overlay=100:0 [mid1];
[in2] lutrgb=b=0, [mid1] overlay=0:100 [mid2];
[in3] null, [mid2] overlay=100:100 [out0]
owdenoise
Apply Overcomplete Wavelet denoiser.
The filter accepts the following options:
depth
Set depth.
Larger depth values will denoise lower frequency components more, but slow down filtering.
Must be an int in the range 8-16, default is 8.
luma_strength, ls
Set luma strength.
Must be a double value in the range 0-1000, default is 1.0.
chroma_strength, cs
Set chroma strength.
Must be a double value in the range 0-1000, default is 1.0.
pad
Add paddings to the input image, and place the original input at the given coordinates x, y.
This filter accepts the following parameters:
width, w
height, h
Specify an expression for the size of the output image with the paddings added. If the value for
width or height is 0, the corresponding input size is used for the output.
The width expression can reference the value set by the height expression, and vice versa.
The default value of width and height is 0.
x
y Specify an expression for the offsets where to place the input image in the padded area with respect
to the top/left border of the output image.
The x expression can reference the value set by the y expression, and vice versa.
The default value of x and y is 0.
color
Specify the color of the padded area. For the syntax of this option, check the "Color" section in the
ffmpeg-utils manual.
The default value of color is "black".
The value for the width, height, x, and y options are expressions containing the following constants:
in_w
in_h
the input video width and height
iw
ih same as in_w and in_h
out_w
out_h
the output width and height, that is the size of the padded area as specified by the width and height
expressions
ow
oh same as out_w and out_h
x
y x and y offsets as specified by the x and y expressions, or NAN if not yet specified
a same as iw / ih
sar input sample aspect ratio
dar input display aspect ratio, it is the same as (iw / ih) * sar
hsub
vsub
horizontal and vertical chroma subsample values. For example for the pixel format "yuv422p" hsub is 2
and vsub is 1.
Examples
· Add paddings with color "violet" to the input video. Output video size is 640x480, the top-left
corner of the input video is placed at column 0, row 40:
pad=640:480:0:40:violet
The example above is equivalent to the following command:
pad=width=640:height=480:x=0:y=40:color=violet
· Pad the input to get an output with dimensions increased by 3/2, and put the input video at the
center of the padded area:
pad="3/2*iw:3/2*ih:(ow-iw)/2:(oh-ih)/2"
· Pad the input to get a squared output with size equal to the maximum value between the input width
and height, and put the input video at the center of the padded area:
pad="max(iw\,ih):ow:(ow-iw)/2:(oh-ih)/2"
· Pad the input to get a final w/h ratio of 16:9:
pad="ih*16/9:ih:(ow-iw)/2:(oh-ih)/2"
· In case of anamorphic video, in order to set the output display aspect correctly, it is necessary to
use sar in the expression, according to the relation:
(ih * X / ih) * sar = output_dar
X = output_dar / sar
Thus the previous example needs to be modified to:
pad="ih*16/9/sar:ih:(ow-iw)/2:(oh-ih)/2"
· Double output size and put the input video in the bottom-right corner of the output padded area:
pad="2*iw:2*ih:ow-iw:oh-ih"
perspective
Correct perspective of video not recorded perpendicular to the screen.
A description of the accepted parameters follows.
x0
y0
x1
y1
x2
y2
x3
y3 Set coordinates expression for top left, top right, bottom left and bottom right corners. Default
values are "0:0:W:0:0:H:W:H" with which perspective will remain unchanged.
The expressions can use the following variables:
W
H the width and height of video frame.
interpolation
Set interpolation for perspective correction.
It accepts the following values:
linear
cubic
Default value is linear.
phase
Delay interlaced video by one field time so that the field order changes.
The intended use is to fix PAL movies that have been captured with the opposite field order to the film-
to-video transfer.
A description of the accepted parameters follows.
mode
Set phase mode.
It accepts the following values:
t Capture field order top-first, transfer bottom-first. Filter will delay the bottom field.
b Capture field order bottom-first, transfer top-first. Filter will delay the top field.
p Capture and transfer with the same field order. This mode only exists for the documentation of
the other options to refer to, but if you actually select it, the filter will faithfully do
nothing.
a Capture field order determined automatically by field flags, transfer opposite. Filter selects
among t and b modes on a frame by frame basis using field flags. If no field information is
available, then this works just like u.
u Capture unknown or varying, transfer opposite. Filter selects among t and b on a frame by frame
basis by analyzing the images and selecting the alternative that produces best match between the
fields.
T Capture top-first, transfer unknown or varying. Filter selects among t and p using image
analysis.
B Capture bottom-first, transfer unknown or varying. Filter selects among b and p using image
analysis.
A Capture determined by field flags, transfer unknown or varying. Filter selects among t, b and p
using field flags and image analysis. If no field information is available, then this works just
like U. This is the default mode.
U Both capture and transfer unknown or varying. Filter selects among t, b and p using image
analysis only.
pixdesctest
Pixel format descriptor test filter, mainly useful for internal testing. The output video should be equal
to the input video.
For example:
format=monow, pixdesctest
can be used to test the monowhite pixel format descriptor definition.
pp
Enable the specified chain of postprocessing subfilters using libpostproc. This library should be
automatically selected with a GPL build ("--enable-gpl"). Subfilters must be separated by '/' and can be
disabled by prepending a '-'. Each subfilter and some options have a short and a long name that can be
used interchangeably, i.e. dr/dering are the same.
The filters accept the following options:
subfilters
Set postprocessing subfilters string.
All subfilters share common options to determine their scope:
a/autoq
Honor the quality commands for this subfilter.
c/chrom
Do chrominance filtering, too (default).
y/nochrom
Do luminance filtering only (no chrominance).
n/noluma
Do chrominance filtering only (no luminance).
These options can be appended after the subfilter name, separated by a '|'.
Available subfilters are:
hb/hdeblock[|difference[|flatness]]
Horizontal deblocking filter
difference
Difference factor where higher values mean more deblocking (default: 32).
flatness
Flatness threshold where lower values mean more deblocking (default: 39).
vb/vdeblock[|difference[|flatness]]
Vertical deblocking filter
difference
Difference factor where higher values mean more deblocking (default: 32).
flatness
Flatness threshold where lower values mean more deblocking (default: 39).
ha/hadeblock[|difference[|flatness]]
Accurate horizontal deblocking filter
difference
Difference factor where higher values mean more deblocking (default: 32).
flatness
Flatness threshold where lower values mean more deblocking (default: 39).
va/vadeblock[|difference[|flatness]]
Accurate vertical deblocking filter
difference
Difference factor where higher values mean more deblocking (default: 32).
flatness
Flatness threshold where lower values mean more deblocking (default: 39).
The horizontal and vertical deblocking filters share the difference and flatness values so you cannot set
different horizontal and vertical thresholds.
h1/x1hdeblock
Experimental horizontal deblocking filter
v1/x1vdeblock
Experimental vertical deblocking filter
dr/dering
Deringing filter
tn/tmpnoise[|threshold1[|threshold2[|threshold3]]], temporal noise reducer
threshold1
larger -> stronger filtering
threshold2
larger -> stronger filtering
threshold3
larger -> stronger filtering
al/autolevels[:f/fullyrange], automatic brightness / contrast correction
f/fullyrange
Stretch luminance to "0-255".
lb/linblenddeint
Linear blend deinterlacing filter that deinterlaces the given block by filtering all lines with a "(1
2 1)" filter.
li/linipoldeint
Linear interpolating deinterlacing filter that deinterlaces the given block by linearly interpolating
every second line.
ci/cubicipoldeint
Cubic interpolating deinterlacing filter deinterlaces the given block by cubically interpolating
every second line.
md/mediandeint
Median deinterlacing filter that deinterlaces the given block by applying a median filter to every
second line.
fd/ffmpegdeint
FFmpeg deinterlacing filter that deinterlaces the given block by filtering every second line with a
"(-1 4 2 4 -1)" filter.
l5/lowpass5
Vertically applied FIR lowpass deinterlacing filter that deinterlaces the given block by filtering
all lines with a "(-1 2 6 2 -1)" filter.
fq/forceQuant[|quantizer]
Overrides the quantizer table from the input with the constant quantizer you specify.
quantizer
Quantizer to use
de/default
Default pp filter combination ("hb|a,vb|a,dr|a")
fa/fast
Fast pp filter combination ("h1|a,v1|a,dr|a")
ac High quality pp filter combination ("ha|a|128|7,va|a,dr|a")
Examples
· Apply horizontal and vertical deblocking, deringing and automatic brightness/contrast:
pp=hb/vb/dr/al
· Apply default filters without brightness/contrast correction:
pp=de/-al
· Apply default filters and temporal denoiser:
pp=default/tmpnoise|1|2|3
· Apply deblocking on luminance only, and switch vertical deblocking on or off automatically depending
on available CPU time:
pp=hb|y/vb|a
psnr
Obtain the average, maximum and minimum PSNR (Peak Signal to Noise Ratio) between two input videos.
This filter takes in input two input videos, the first input is considered the "main" source and is
passed unchanged to the output. The second input is used as a "reference" video for computing the PSNR.
Both video inputs must have the same resolution and pixel format for this filter to work correctly. Also
it assumes that both inputs have the same number of frames, which are compared one by one.
The obtained average PSNR is printed through the logging system.
The filter stores the accumulated MSE (mean squared error) of each frame, and at the end of the
processing it is averaged across all frames equally, and the following formula is applied to obtain the
PSNR:
PSNR = 10*log10(MAX^2/MSE)
Where MAX is the average of the maximum values of each component of the image.
The description of the accepted parameters follows.
stats_file, f
If specified the filter will use the named file to save the PSNR of each individual frame.
The file printed if stats_file is selected, contains a sequence of key/value pairs of the form key:value
for each compared couple of frames.
A description of each shown parameter follows:
n sequential number of the input frame, starting from 1
mse_avg
Mean Square Error pixel-by-pixel average difference of the compared frames, averaged over all the
image components.
mse_y, mse_u, mse_v, mse_r, mse_g, mse_g, mse_a
Mean Square Error pixel-by-pixel average difference of the compared frames for the component
specified by the suffix.
psnr_y, psnr_u, psnr_v, psnr_r, psnr_g, psnr_b, psnr_a
Peak Signal to Noise ratio of the compared frames for the component specified by the suffix.
For example:
movie=ref_movie.mpg, setpts=PTS-STARTPTS [main];
[main][ref] psnr="stats_file=stats.log" [out]
On this example the input file being processed is compared with the reference file ref_movie.mpg. The
PSNR of each individual frame is stored in stats.log.
pullup
Pulldown reversal (inverse telecine) filter, capable of handling mixed hard-telecine, 24000/1001 fps
progressive, and 30000/1001 fps progressive content.
The pullup filter is designed to take advantage of future context in making its decisions. This filter is
stateless in the sense that it does not lock onto a pattern to follow, but it instead looks forward to
the following fields in order to identify matches and rebuild progressive frames.
To produce content with an even framerate, insert the fps filter after pullup, use "fps=24000/1001" if
the input frame rate is 29.97fps, "fps=24" for 30fps and the (rare) telecined 25fps input.
The filter accepts the following options:
jl
jr
jt
jb These options set the amount of "junk" to ignore at the left, right, top, and bottom of the image,
respectively. Left and right are in units of 8 pixels, while top and bottom are in units of 2 lines.
The default is 8 pixels on each side.
sb Set the strict breaks. Setting this option to 1 will reduce the chances of filter generating an
occasional mismatched frame, but it may also cause an excessive number of frames to be dropped during
high motion sequences. Conversely, setting it to -1 will make filter match fields more easily. This
may help processing of video where there is slight blurring between the fields, but may also cause
there to be interlaced frames in the output. Default value is 0.
mp Set the metric plane to use. It accepts the following values:
l Use luma plane.
u Use chroma blue plane.
v Use chroma red plane.
This option may be set to use chroma plane instead of the default luma plane for doing filter's
computations. This may improve accuracy on very clean source material, but more likely will decrease
accuracy, especially if there is chroma noise (rainbow effect) or any grayscale video. The main
purpose of setting mp to a chroma plane is to reduce CPU load and make pullup usable in realtime on
slow machines.
For best results (without duplicated frames in the output file) it is necessary to change the output
frame rate. For example, to inverse telecine NTSC input:
ffmpeg -i input -vf pullup -r 24000/1001 ...
removelogo
Suppress a TV station logo, using an image file to determine which pixels comprise the logo. It works by
filling in the pixels that comprise the logo with neighboring pixels.
The filter accepts the following options:
filename, f
Set the filter bitmap file, which can be any image format supported by libavformat. The width and
height of the image file must match those of the video stream being processed.
Pixels in the provided bitmap image with a value of zero are not considered part of the logo, non-zero
pixels are considered part of the logo. If you use white (255) for the logo and black (0) for the rest,
you will be safe. For making the filter bitmap, it is recommended to take a screen capture of a black
frame with the logo visible, and then using a threshold filter followed by the erode filter once or
twice.
If needed, little splotches can be fixed manually. Remember that if logo pixels are not covered, the
filter quality will be much reduced. Marking too many pixels as part of the logo does not hurt as much,
but it will increase the amount of blurring needed to cover over the image and will destroy more
information than necessary, and extra pixels will slow things down on a large logo.
rotate
Rotate video by an arbitrary angle expressed in radians.
The filter accepts the following options:
A description of the optional parameters follows.
angle, a
Set an expression for the angle by which to rotate the input video clockwise, expressed as a number
of radians. A negative value will result in a counter-clockwise rotation. By default it is set to
"0".
This expression is evaluated for each frame.
out_w, ow
Set the output width expression, default value is "iw". This expression is evaluated just once
during configuration.
out_h, oh
Set the output height expression, default value is "ih". This expression is evaluated just once
during configuration.
bilinear
Enable bilinear interpolation if set to 1, a value of 0 disables it. Default value is 1.
fillcolor, c
Set the color used to fill the output area not covered by the rotated image. For the generalsyntax of
this option, check the "Color" section in the ffmpeg-utils manual. If the special value "none" is
selected then no background is printed (useful for example if the background is never shown).
Default value is "black".
The expressions for the angle and the output size can contain the following constants and functions:
n sequential number of the input frame, starting from 0. It is always NAN before the first frame is
filtered.
t time in seconds of the input frame, it is set to 0 when the filter is configured. It is always NAN
before the first frame is filtered.
hsub
vsub
horizontal and vertical chroma subsample values. For example for the pixel format "yuv422p" hsub is 2
and vsub is 1.
in_w, iw
in_h, ih
the input video width and height
out_w, ow
out_h, oh
the output width and height, that is the size of the padded area as specified by the width and height
expressions
rotw(a)
roth(a)
the minimal width/height required for completely containing the input video rotated by a radians.
These are only available when computing the out_w and out_h expressions.
Examples
· Rotate the input by PI/6 radians clockwise:
rotate=PI/6
· Rotate the input by PI/6 radians counter-clockwise:
rotate=-PI/6
· Rotate the input by 45 degrees clockwise:
rotate=45*PI/180
· Apply a constant rotation with period T, starting from an angle of PI/3:
rotate=PI/3+2*PI*t/T
· Make the input video rotation oscillating with a period of T seconds and an amplitude of A radians:
rotate=A*sin(2*PI/T*t)
· Rotate the video, output size is choosen so that the whole rotating input video is always completely
contained in the output:
rotate='2*PI*t:ow=hypot(iw,ih):oh=ow'
· Rotate the video, reduce the output size so that no background is ever shown:
rotate=2*PI*t:ow='min(iw,ih)/sqrt(2)':oh=ow:c=none
Commands
The filter supports the following commands:
a, angle
Set the angle expression. The command accepts the same syntax of the corresponding option.
If the specified expression is not valid, it is kept at its current value.
sab
Apply Shape Adaptive Blur.
The filter accepts the following options:
luma_radius, lr
Set luma blur filter strength, must be a value in range 0.1-4.0, default value is 1.0. A greater
value will result in a more blurred image, and in slower processing.
luma_pre_filter_radius, lpfr
Set luma pre-filter radius, must be a value in the 0.1-2.0 range, default value is 1.0.
luma_strength, ls
Set luma maximum difference between pixels to still be considered, must be a value in the 0.1-100.0
range, default value is 1.0.
chroma_radius, cr
Set chroma blur filter strength, must be a value in range 0.1-4.0. A greater value will result in a
more blurred image, and in slower processing.
chroma_pre_filter_radius, cpfr
Set chroma pre-filter radius, must be a value in the 0.1-2.0 range.
chroma_strength, cs
Set chroma maximum difference between pixels to still be considered, must be a value in the 0.1-100.0
range.
Each chroma option value, if not explicitly specified, is set to the corresponding luma option value.
scale
Scale (resize) the input video, using the libswscale library.
The scale filter forces the output display aspect ratio to be the same of the input, by changing the
output sample aspect ratio.
If the input image format is different from the format requested by the next filter, the scale filter
will convert the input to the requested format.
Options
The filter accepts the following options, or any of the options supported by the libswscale scaler.
See the ffmpeg-scaler manual for the complete list of scaler options.
width, w
height, h
Set the output video dimension expression. Default value is the input dimension.
If the value is 0, the input width is used for the output.
If one of the values is -1, the scale filter will use a value that maintains the aspect ratio of the
input image, calculated from the other specified dimension. If both of them are -1, the input size is
used
If one of the values is -n with n > 1, the scale filter will also use a value that maintains the
aspect ratio of the input image, calculated from the other specified dimension. After that it will,
however, make sure that the calculated dimension is divisible by n and adjust the value if necessary.
See below for the list of accepted constants for use in the dimension expression.
interl
Set the interlacing mode. It accepts the following values:
1 Force interlaced aware scaling.
0 Do not apply interlaced scaling.
-1 Select interlaced aware scaling depending on whether the source frames are flagged as interlaced
or not.
Default value is 0.
flags
Set libswscale scaling flags. See the ffmpeg-scaler manual for the complete list of values. If not
explictly specified the filter applies the default flags.
size, s
Set the video size. For the syntax of this option, check the "Video size" section in the ffmpeg-utils
manual.
in_color_matrix
out_color_matrix
Set in/output YCbCr color space type.
This allows the autodetected value to be overridden as well as allows forcing a specific value used
for the output and encoder.
If not specified, the color space type depends on the pixel format.
Possible values:
auto
Choose automatically.
bt709
Format conforming to International Telecommunication Union (ITU) Recommendation BT.709.
fcc Set color space conforming to the United States Federal Communications Commission (FCC) Code of
Federal Regulations (CFR) Title 47 (2003) 73.682 (a).
bt601
Set color space conforming to:
· ITU Radiocommunication Sector (ITU-R) Recommendation BT.601
· ITU-R Rec. BT.470-6 (1998) Systems B, B1, and G
· Society of Motion Picture and Television Engineers (SMPTE) ST 170:2004
smpte240m
Set color space conforming to SMPTE ST 240:1999.
in_range
out_range
Set in/output YCbCr sample range.
This allows the autodetected value to be overridden as well as allows forcing a specific value used
for the output and encoder. If not specified, the range depends on the pixel format. Possible values:
auto
Choose automatically.
jpeg/full/pc
Set full range (0-255 in case of 8-bit luma).
mpeg/tv
Set "MPEG" range (16-235 in case of 8-bit luma).
force_original_aspect_ratio
Enable decreasing or increasing output video width or height if necessary to keep the original aspect
ratio. Possible values:
disable
Scale the video as specified and disable this feature.
decrease
The output video dimensions will automatically be decreased if needed.
increase
The output video dimensions will automatically be increased if needed.
One useful instance of this option is that when you know a specific device's maximum allowed
resolution, you can use this to limit the output video to that, while retaining the aspect ratio. For
example, device A allows 1280x720 playback, and your video is 1920x800. Using this option (set it to
decrease) and specifying 1280x720 to the command line makes the output 1280x533.
Please note that this is a different thing than specifying -1 for w or h, you still need to specify
the output resolution for this option to work.
The values of the w and h options are expressions containing the following constants:
in_w
in_h
the input width and height
iw
ih same as in_w and in_h
out_w
out_h
the output (scaled) width and height
ow
oh same as out_w and out_h
a same as iw / ih
sar input sample aspect ratio
dar input display aspect ratio. Calculated from "(iw / ih) * sar".
hsub
vsub
horizontal and vertical input chroma subsample values. For example for the pixel format "yuv422p"
hsub is 2 and vsub is 1.
ohsub
ovsub
horizontal and vertical output chroma subsample values. For example for the pixel format "yuv422p"
hsub is 2 and vsub is 1.
Examples
· Scale the input video to a size of 200x100:
scale=w=200:h=100
This is equivalent to:
scale=200:100
or:
scale=200x100
· Specify a size abbreviation for the output size:
scale=qcif
which can also be written as:
scale=size=qcif
· Scale the input to 2x:
scale=w=2*iw:h=2*ih
· The above is the same as:
scale=2*in_w:2*in_h
· Scale the input to 2x with forced interlaced scaling:
scale=2*iw:2*ih:interl=1
· Scale the input to half size:
scale=w=iw/2:h=ih/2
· Increase the width, and set the height to the same size:
scale=3/2*iw:ow
· Seek for Greek harmony:
scale=iw:1/PHI*iw
scale=ih*PHI:ih
· Increase the height, and set the width to 3/2 of the height:
scale=w=3/2*oh:h=3/5*ih
· Increase the size, but make the size a multiple of the chroma subsample values:
scale="trunc(3/2*iw/hsub)*hsub:trunc(3/2*ih/vsub)*vsub"
· Increase the width to a maximum of 500 pixels, keep the same input aspect ratio:
scale=w='min(500\, iw*3/2):h=-1'
separatefields
The "separatefields" takes a frame-based video input and splits each frame into its components fields,
producing a new half height clip with twice the frame rate and twice the frame count.
This filter use field-dominance information in frame to decide which of each pair of fields to place
first in the output. If it gets it wrong use setfield filter before "separatefields" filter.
setdar, setsar
The "setdar" filter sets the Display Aspect Ratio for the filter output video.
This is done by changing the specified Sample (aka Pixel) Aspect Ratio, according to the following
equation:
= / *
Keep in mind that the "setdar" filter does not modify the pixel dimensions of the video frame. Also the
display aspect ratio set by this filter may be changed by later filters in the filterchain, e.g. in case
of scaling or if another "setdar" or a "setsar" filter is applied.
The "setsar" filter sets the Sample (aka Pixel) Aspect Ratio for the filter output video.
Note that as a consequence of the application of this filter, the output display aspect ratio will change
according to the equation above.
Keep in mind that the sample aspect ratio set by the "setsar" filter may be changed by later filters in
the filterchain, e.g. if another "setsar" or a "setdar" filter is applied.
The filters accept the following options:
r, ratio, dar ("setdar" only), sar ("setsar" only)
Set the aspect ratio used by the filter.
The parameter can be a floating point number string, an expression, or a string of the form num:den,
where num and den are the numerator and denominator of the aspect ratio. If the parameter is not
specified, it is assumed the value "0". In case the form "num:den" is used, the ":" character should
be escaped.
max Set the maximum integer value to use for expressing numerator and denominator when reducing the
expressed aspect ratio to a rational. Default value is 100.
The parameter sar is an expression containing the following constants:
E, PI, PHI
the corresponding mathematical approximated values for e (euler number), pi (greek PI), phi (golden
ratio)
w, h
the input width and height
a same as w / h
sar input sample aspect ratio
dar input display aspect ratio, it is the same as (w / h) * sar
hsub, vsub
horizontal and vertical chroma subsample values. For example for the pixel format "yuv422p" hsub is 2
and vsub is 1.
Examples
· To change the display aspect ratio to 16:9, specify one of the following:
setdar=dar=1.77777
setdar=dar=16/9
setdar=dar=1.77777
· To change the sample aspect ratio to 10:11, specify:
setsar=sar=10/11
· To set a display aspect ratio of 16:9, and specify a maximum integer value of 1000 in the aspect
ratio reduction, use the command:
setdar=ratio=16/9:max=1000
setfield
Force field for the output video frame.
The "setfield" filter marks the interlace type field for the output frames. It does not change the input
frame, but only sets the corresponding property, which affects how the frame is treated by following
filters (e.g. "fieldorder" or "yadif").
The filter accepts the following options:
mode
Available values are:
auto
Keep the same field property.
bff Mark the frame as bottom-field-first.
tff Mark the frame as top-field-first.
prog
Mark the frame as progressive.
showinfo
Show a line containing various information for each input video frame. The input video is not modified.
The shown line contains a sequence of key/value pairs of the form key:value.
A description of each shown parameter follows:
n sequential number of the input frame, starting from 0
pts Presentation TimeStamp of the input frame, expressed as a number of time base units. The time base
unit depends on the filter input pad.
pts_time
Presentation TimeStamp of the input frame, expressed as a number of seconds
pos position of the frame in the input stream, -1 if this information in unavailable and/or meaningless
(for example in case of synthetic video)
fmt pixel format name
sar sample aspect ratio of the input frame, expressed in the form num/den
s size of the input frame. For the syntax of this option, check the "Video size" section in the ffmpeg-
utils manual.
i interlaced mode ("P" for "progressive", "T" for top field first, "B" for bottom field first)
iskey
1 if the frame is a key frame, 0 otherwise
type
picture type of the input frame ("I" for an I-frame, "P" for a P-frame, "B" for a B-frame, "?" for
unknown type). Check also the documentation of the "AVPictureType" enum and of the
"av_get_picture_type_char" function defined in libavutil/avutil.h.
checksum
Adler-32 checksum (printed in hexadecimal) of all the planes of the input frame
plane_checksum
Adler-32 checksum (printed in hexadecimal) of each plane of the input frame, expressed in the form
"[c0 c1 c2 c3]"
smartblur
Blur the input video without impacting the outlines.
The filter accepts the following options:
luma_radius, lr
Set the luma radius. The option value must be a float number in the range [0.1,5.0] that specifies
the variance of the gaussian filter used to blur the image (slower if larger). Default value is 1.0.
luma_strength, ls
Set the luma strength. The option value must be a float number in the range [-1.0,1.0] that
configures the blurring. A value included in [0.0,1.0] will blur the image whereas a value included
in [-1.0,0.0] will sharpen the image. Default value is 1.0.
luma_threshold, lt
Set the luma threshold used as a coefficient to determine whether a pixel should be blurred or not.
The option value must be an integer in the range [-30,30]. A value of 0 will filter all the image, a
value included in [0,30] will filter flat areas and a value included in [-30,0] will filter edges.
Default value is 0.
chroma_radius, cr
Set the chroma radius. The option value must be a float number in the range [0.1,5.0] that specifies
the variance of the gaussian filter used to blur the image (slower if larger). Default value is 1.0.
chroma_strength, cs
Set the chroma strength. The option value must be a float number in the range [-1.0,1.0] that
configures the blurring. A value included in [0.0,1.0] will blur the image whereas a value included
in [-1.0,0.0] will sharpen the image. Default value is 1.0.
chroma_threshold, ct
Set the chroma threshold used as a coefficient to determine whether a pixel should be blurred or not.
The option value must be an integer in the range [-30,30]. A value of 0 will filter all the image, a
value included in [0,30] will filter flat areas and a value included in [-30,0] will filter edges.
Default value is 0.
If a chroma option is not explicitly set, the corresponding luma value is set.
stereo3d
Convert between different stereoscopic image formats.
The filters accept the following options:
in Set stereoscopic image format of input.
Available values for input image formats are:
sbsl
side by side parallel (left eye left, right eye right)
sbsr
side by side crosseye (right eye left, left eye right)
sbs2l
side by side parallel with half width resolution (left eye left, right eye right)
sbs2r
side by side crosseye with half width resolution (right eye left, left eye right)
abl above-below (left eye above, right eye below)
abr above-below (right eye above, left eye below)
ab2l
above-below with half height resolution (left eye above, right eye below)
ab2r
above-below with half height resolution (right eye above, left eye below)
al alternating frames (left eye first, right eye second)
ar alternating frames (right eye first, left eye second)
Default value is sbsl.
out Set stereoscopic image format of output.
Available values for output image formats are all the input formats as well as:
arbg
anaglyph red/blue gray (red filter on left eye, blue filter on right eye)
argg
anaglyph red/green gray (red filter on left eye, green filter on right eye)
arcg
anaglyph red/cyan gray (red filter on left eye, cyan filter on right eye)
arch
anaglyph red/cyan half colored (red filter on left eye, cyan filter on right eye)
arcc
anaglyph red/cyan color (red filter on left eye, cyan filter on right eye)
arcd
anaglyph red/cyan color optimized with the least squares projection of dubois (red filter on left
eye, cyan filter on right eye)
agmg
anaglyph green/magenta gray (green filter on left eye, magenta filter on right eye)
agmh
anaglyph green/magenta half colored (green filter on left eye, magenta filter on right eye)
agmc
anaglyph green/magenta colored (green filter on left eye, magenta filter on right eye)
agmd
anaglyph green/magenta color optimized with the least squares projection of dubois (green filter
on left eye, magenta filter on right eye)
aybg
anaglyph yellow/blue gray (yellow filter on left eye, blue filter on right eye)
aybh
anaglyph yellow/blue half colored (yellow filter on left eye, blue filter on right eye)
aybc
anaglyph yellow/blue colored (yellow filter on left eye, blue filter on right eye)
aybd
anaglyph yellow/blue color optimized with the least squares projection of dubois (yellow filter
on left eye, blue filter on right eye)
irl interleaved rows (left eye has top row, right eye starts on next row)
irr interleaved rows (right eye has top row, left eye starts on next row)
ml mono output (left eye only)
mr mono output (right eye only)
Default value is arcd.
Examples
· Convert input video from side by side parallel to anaglyph yellow/blue dubois:
stereo3d=sbsl:aybd
· Convert input video from above bellow (left eye above, right eye below) to side by side crosseye.
stereo3d=abl:sbsr
spp
Apply a simple postprocessing filter that compresses and decompresses the image at several (or - in the
case of quality level 6 - all) shifts and average the results.
The filter accepts the following options:
quality
Set quality. This option defines the number of levels for averaging. It accepts an integer in the
range 0-6. If set to 0, the filter will have no effect. A value of 6 means the higher quality. For
each increment of that value the speed drops by a factor of approximately 2. Default value is 3.
qp Force a constant quantization parameter. If not set, the filter will use the QP from the video stream
(if available).
mode
Set thresholding mode. Available modes are:
hard
Set hard thresholding (default).
soft
Set soft thresholding (better de-ringing effect, but likely blurrier).
use_bframe_qp
Enable the use of the QP from the B-Frames if set to 1. Using this option may cause flicker since the
B-Frames have often larger QP. Default is 0 (not enabled).
subtitles
Draw subtitles on top of input video using the libass library.
To enable compilation of this filter you need to configure FFmpeg with "--enable-libass". This filter
also requires a build with libavcodec and libavformat to convert the passed subtitles file to ASS
(Advanced Substation Alpha) subtitles format.
The filter accepts the following options:
filename, f
Set the filename of the subtitle file to read. It must be specified.
original_size
Specify the size of the original video, the video for which the ASS file was composed. For the syntax
of this option, check the "Video size" section in the ffmpeg-utils manual. Due to a misdesign in ASS
aspect ratio arithmetic, this is necessary to correctly scale the fonts if the aspect ratio has been
changed.
charenc
Set subtitles input character encoding. "subtitles" filter only. Only useful if not UTF-8.
If the first key is not specified, it is assumed that the first value specifies the filename.
For example, to render the file sub.srt on top of the input video, use the command:
subtitles=sub.srt
which is equivalent to:
subtitles=filename=sub.srt
super2xsai
Scale the input by 2x and smooth using the Super2xSaI (Scale and Interpolate) pixel art scaling
algorithm.
Useful for enlarging pixel art images without reducing sharpness.
swapuv
Swap U & V plane.
telecine
Apply telecine process to the video.
This filter accepts the following options:
first_field
top, t
top field first
bottom, b
bottom field first The default value is "top".
pattern
A string of numbers representing the pulldown pattern you wish to apply. The default value is 23.
Some typical patterns:
NTSC output (30i):
27.5p: 32222
24p: 23 (classic)
24p: 2332 (preferred)
20p: 33
18p: 334
16p: 3444
PAL output (25i):
27.5p: 12222
24p: 222222222223 ("Euro pulldown")
16.67p: 33
16p: 33333334
thumbnail
Select the most representative frame in a given sequence of consecutive frames.
The filter accepts the following options:
n Set the frames batch size to analyze; in a set of n frames, the filter will pick one of them, and
then handle the next batch of n frames until the end. Default is 100.
Since the filter keeps track of the whole frames sequence, a bigger n value will result in a higher
memory usage, so a high value is not recommended.
Examples
· Extract one picture each 50 frames:
thumbnail=50
· Complete example of a thumbnail creation with ffmpeg:
ffmpeg -i in.avi -vf thumbnail,scale=300:200 -frames:v 1 out.png
tile
Tile several successive frames together.
The filter accepts the following options:
layout
Set the grid size (i.e. the number of lines and columns). For the syntax of this option, check the
"Video size" section in the ffmpeg-utils manual.
nb_frames
Set the maximum number of frames to render in the given area. It must be less than or equal to wxh.
The default value is 0, meaning all the area will be used.
margin
Set the outer border margin in pixels.
padding
Set the inner border thickness (i.e. the number of pixels between frames). For more advanced padding
options (such as having different values for the edges), refer to the pad video filter.
color
Specify the color of the unused areaFor the syntax of this option, check the "Color" section in the
ffmpeg-utils manual. The default value of color is "black".
Examples
· Produce 8x8 PNG tiles of all keyframes (-skip_frame nokey) in a movie:
ffmpeg -skip_frame nokey -i file.avi -vf 'scale=128:72,tile=8x8' -an -vsync 0 keyframes%03d.png
The -vsync 0 is necessary to prevent ffmpeg from duplicating each output frame to accomodate the
originally detected frame rate.
· Display 5 pictures in an area of "3x2" frames, with 7 pixels between them, and 2 pixels of initial
margin, using mixed flat and named options:
tile=3x2:nb_frames=5:padding=7:margin=2
tinterlace
Perform various types of temporal field interlacing.
Frames are counted starting from 1, so the first input frame is considered odd.
The filter accepts the following options:
mode
Specify the mode of the interlacing. This option can also be specified as a value alone. See below
for a list of values for this option.
Available values are:
merge, 0
Move odd frames into the upper field, even into the lower field, generating a double height frame
at half frame rate.
drop_odd, 1
Only output even frames, odd frames are dropped, generating a frame with unchanged height at half
frame rate.
drop_even, 2
Only output odd frames, even frames are dropped, generating a frame with unchanged height at half
frame rate.
pad, 3
Expand each frame to full height, but pad alternate lines with black, generating a frame with
double height at the same input frame rate.
interleave_top, 4
Interleave the upper field from odd frames with the lower field from even frames, generating a
frame with unchanged height at half frame rate.
interleave_bottom, 5
Interleave the lower field from odd frames with the upper field from even frames, generating a
frame with unchanged height at half frame rate.
interlacex2, 6
Double frame rate with unchanged height. Frames are inserted each containing the second temporal
field from the previous input frame and the first temporal field from the next input frame. This
mode relies on the top_field_first flag. Useful for interlaced video displays with no field
synchronisation.
Numeric values are deprecated but are accepted for backward compatibility reasons.
Default mode is "merge".
flags
Specify flags influencing the filter process.
Available value for flags is:
low_pass_filter, vlfp
Enable vertical low-pass filtering in the filter. Vertical low-pass filtering is required when
creating an interlaced destination from a progressive source which contains high-frequency
vertical detail. Filtering will reduce interlace 'twitter' and Moire patterning.
Vertical low-pass filtering can only be enabled for mode interleave_top and interleave_bottom.
transpose
Transpose rows with columns in the input video and optionally flip it.
This filter accepts the following options:
dir Specify the transposition direction.
Can assume the following values:
0, 4, cclock_flip
Rotate by 90 degrees counterclockwise and vertically flip (default), that is:
L.R L.l
. . -> . .
l.r R.r
1, 5, clock
Rotate by 90 degrees clockwise, that is:
L.R l.L
. . -> . .
l.r r.R
2, 6, cclock
Rotate by 90 degrees counterclockwise, that is:
L.R R.r
. . -> . .
l.r L.l
3, 7, clock_flip
Rotate by 90 degrees clockwise and vertically flip, that is:
L.R r.R
. . -> . .
l.r l.L
For values between 4-7, the transposition is only done if the input video geometry is portrait and
not landscape. These values are deprecated, the "passthrough" option should be used instead.
Numerical values are deprecated, and should be dropped in favor of symbolic constants.
passthrough
Do not apply the transposition if the input geometry matches the one specified by the specified
value. It accepts the following values:
none
Always apply transposition.
portrait
Preserve portrait geometry (when height >= width).
landscape
Preserve landscape geometry (when width >= height).
Default value is "none".
For example to rotate by 90 degrees clockwise and preserve portrait layout:
transpose=dir=1:passthrough=portrait
The command above can also be specified as:
transpose=1:portrait
trim
Trim the input so that the output contains one continuous subpart of the input.
This filter accepts the following options:
start
Specify time of the start of the kept section, i.e. the frame with the timestamp start will be the
first frame in the output.
end Specify time of the first frame that will be dropped, i.e. the frame immediately preceding the one
with the timestamp end will be the last frame in the output.
start_pts
Same as start, except this option sets the start timestamp in timebase units instead of seconds.
end_pts
Same as end, except this option sets the end timestamp in timebase units instead of seconds.
duration
Specify maximum duration of the output.
start_frame
Number of the first frame that should be passed to output.
end_frame
Number of the first frame that should be dropped.
start, end, duration are expressed as time duration specifications, check the "Time duration" section in
the ffmpeg-utils manual.
Note that the first two sets of the start/end options and the duration option look at the frame
timestamp, while the _frame variants simply count the frames that pass through the filter. Also note that
this filter does not modify the timestamps. If you wish that the output timestamps start at zero, insert
a setpts filter after the trim filter.
If multiple start or end options are set, this filter tries to be greedy and keep all the frames that
match at least one of the specified constraints. To keep only the part that matches all the constraints
at once, chain multiple trim filters.
The defaults are such that all the input is kept. So it is possible to set e.g. just the end values to
keep everything before the specified time.
Examples:
· drop everything except the second minute of input
ffmpeg -i INPUT -vf trim=60:120
· keep only the first second
ffmpeg -i INPUT -vf trim=duration=1
unsharp
Sharpen or blur the input video.
It accepts the following parameters:
luma_msize_x, lx
Set the luma matrix horizontal size. It must be an odd integer between 3 and 63, default value is 5.
luma_msize_y, ly
Set the luma matrix vertical size. It must be an odd integer between 3 and 63, default value is 5.
luma_amount, la
Set the luma effect strength. It can be a float number, reasonable values lay between -1.5 and 1.5.
Negative values will blur the input video, while positive values will sharpen it, a value of zero
will disable the effect.
Default value is 1.0.
chroma_msize_x, cx
Set the chroma matrix horizontal size. It must be an odd integer between 3 and 63, default value is
5.
chroma_msize_y, cy
Set the chroma matrix vertical size. It must be an odd integer between 3 and 63, default value is 5.
chroma_amount, ca
Set the chroma effect strength. It can be a float number, reasonable values lay between -1.5 and 1.5.
Negative values will blur the input video, while positive values will sharpen it, a value of zero
will disable the effect.
Default value is 0.0.
opencl
If set to 1, specify using OpenCL capabilities, only available if FFmpeg was configured with
"--enable-opencl". Default value is 0.
All parameters are optional and default to the equivalent of the string '5:5:1.0:5:5:0.0'.
Examples
· Apply strong luma sharpen effect:
unsharp=luma_msize_x=7:luma_msize_y=7:luma_amount=2.5
· Apply strong blur of both luma and chroma parameters:
unsharp=7:7:-2:7:7:-2
vidstabdetect
Analyze video stabilization/deshaking. Perform pass 1 of 2, see vidstabtransform for pass 2.
This filter generates a file with relative translation and rotation transform information about
subsequent frames, which is then used by the vidstabtransform filter.
To enable compilation of this filter you need to configure FFmpeg with "--enable-libvidstab".
This filter accepts the following options:
result
Set the path to the file used to write the transforms information. Default value is transforms.trf.
shakiness
Set how shaky the video is and how quick the camera is. It accepts an integer in the range 1-10, a
value of 1 means little shakiness, a value of 10 means strong shakiness. Default value is 5.
accuracy
Set the accuracy of the detection process. It must be a value in the range 1-15. A value of 1 means
low accuracy, a value of 15 means high accuracy. Default value is 15.
stepsize
Set stepsize of the search process. The region around minimum is scanned with 1 pixel resolution.
Default value is 6.
mincontrast
Set minimum contrast. Below this value a local measurement field is discarded. Must be a floating
point value in the range 0-1. Default value is 0.3.
tripod
Set reference frame number for tripod mode.
If enabled, the motion of the frames is compared to a reference frame in the filtered stream,
identified by the specified number. The idea is to compensate all movements in a more-or-less static
scene and keep the camera view absolutely still.
If set to 0, it is disabled. The frames are counted starting from 1.
show
Show fields and transforms in the resulting frames. It accepts an integer in the range 0-2. Default
value is 0, which disables any visualization.
Examples
· Use default values:
vidstabdetect
· Analyze strongly shaky movie and put the results in file mytransforms.trf:
vidstabdetect=shakiness=10:accuracy=15:result="mytransforms.trf"
· Visualize the result of internal transformations in the resulting video:
vidstabdetect=show=1
· Analyze a video with medium shakiness using ffmpeg:
ffmpeg -i input -vf vidstabdetect=shakiness=5:show=1 dummy.avi
vidstabtransform
Video stabilization/deshaking: pass 2 of 2, see vidstabdetect for pass 1.
Read a file with transform information for each frame and apply/compensate them. Together with the
vidstabdetect filter this can be used to deshake videos. See also .
It is important to also use the unsharp filter, see below.
To enable compilation of this filter you need to configure FFmpeg with "--enable-libvidstab".
Options
input
Set path to the file used to read the transforms. Default value is transforms.trf).
smoothing
Set the number of frames (value*2 + 1) used for lowpass filtering the camera movements. Default value
is 10.
For example a number of 10 means that 21 frames are used (10 in the past and 10 in the future) to
smoothen the motion in the video. A larger values leads to a smoother video, but limits the
acceleration of the camera (pan/tilt movements). 0 is a special case where a static camera is
simulated.
optalgo
Set the camera path optimization algorithm.
Accepted values are:
gauss
gaussian kernel low-pass filter on camera motion (default)
avg averaging on transformations
maxshift
Set maximal number of pixels to translate frames. Default value is -1, meaning no limit.
maxangle
Set maximal angle in radians (degree*PI/180) to rotate frames. Default value is -1, meaning no limit.
crop
Specify how to deal with borders that may be visible due to movement compensation.
Available values are:
keep
keep image information from previous frame (default)
black
fill the border black
invert
Invert transforms if set to 1. Default value is 0.
relative
Consider transforms as relative to previsou frame if set to 1, absolute if set to 0. Default value is
0.
zoom
Set percentage to zoom. A positive value will result in a zoom-in effect, a negative value in a zoom-
out effect. Default value is 0 (no zoom).
optzoom
Set optimal zooming to avoid borders.
Accepted values are:
0 disabled
1 optimal static zoom value is determined (only very strong movements will lead to visible borders)
(default)
2 optimal adaptive zoom value is determined (no borders will be visible), see zoomspeed
Note that the value given at zoom is added to the one calculated here.
zoomspeed
Set percent to zoom maximally each frame (enabled when optzoom is set to 2). Range is from 0 to 5,
default value is 0.25.
interpol
Specify type of interpolation.
Available values are:
no no interpolation
linear
linear only horizontal
bilinear
linear in both directions (default)
bicubic
cubic in both directions (slow)
tripod
Enable virtual tripod mode if set to 1, which is equivalent to "relative=0:smoothing=0". Default
value is 0.
Use also "tripod" option of vidstabdetect.
debug
Increase log verbosity if set to 1. Also the detected global motions are written to the temporary
file global_motions.trf. Default value is 0.
Examples
· Use ffmpeg for a typical stabilization with default values:
ffmpeg -i inp.mpeg -vf vidstabtransform,unsharp=5:5:0.8:3:3:0.4 inp_stabilized.mpeg
Note the use of the unsharp filter which is always recommended.
· Zoom in a bit more and load transform data from a given file:
vidstabtransform=zoom=5:input="mytransforms.trf"
· Smoothen the video even more:
vidstabtransform=smoothing=30
vflip
Flip the input video vertically.
For example, to vertically flip a video with ffmpeg:
ffmpeg -i in.avi -vf "vflip" out.avi
vignette
Make or reverse a natural vignetting effect.
The filter accepts the following options:
angle, a
Set lens angle expression as a number of radians.
The value is clipped in the "[0,PI/2]" range.
Default value: "PI/5"
x0
y0 Set center coordinates expressions. Respectively "w/2" and "h/2" by default.
mode
Set forward/backward mode.
Available modes are:
forward
The larger the distance from the central point, the darker the image becomes.
backward
The larger the distance from the central point, the brighter the image becomes. This can be used
to reverse a vignette effect, though there is no automatic detection to extract the lens angle
and other settings (yet). It can also be used to create a burning effect.
Default value is forward.
eval
Set evaluation mode for the expressions (angle, x0, y0).
It accepts the following values:
init
Evaluate expressions only once during the filter initialization.
frame
Evaluate expressions for each incoming frame. This is way slower than the init mode since it
requires all the scalers to be re-computed, but it allows advanced dynamic expressions.
Default value is init.
dither
Set dithering to reduce the circular banding effects. Default is 1 (enabled).
aspect
Set vignette aspect. This setting allows to adjust the shape of the vignette. Setting this value to
the SAR of the input will make a rectangular vignetting following the dimensions of the video.
Default is "1/1".
Expressions
The alpha, x0 and y0 expressions can contain the following parameters.
w
h input width and height
n the number of input frame, starting from 0
pts the PTS (Presentation TimeStamp) time of the filtered video frame, expressed in TB units, NAN if
undefined
r frame rate of the input video, NAN if the input frame rate is unknown
t the PTS (Presentation TimeStamp) of the filtered video frame, expressed in seconds, NAN if undefined
tb time base of the input video
Examples
· Apply simple strong vignetting effect:
vignette=PI/4
· Make a flickering vignetting:
vignette='PI/4+random(1)*PI/50':eval=frame
w3fdif
Deinterlace the input video ("w3fdif" stands for "Weston 3 Field Deinterlacing Filter").
Based on the process described by Martin Weston for BBC R&D, and implemented based on the de-interlace
algorithm written by Jim Easterbrook for BBC R&D, the Weston 3 field deinterlacing filter uses filter
coefficients calculated by BBC R&D.
There are two sets of filter coefficients, so called "simple": and "complex". Which set of filter
coefficients is used can be set by passing an optional parameter:
filter
Set the interlacing filter coefficients. Accepts one of the following values:
simple
Simple filter coefficient set.
complex
More-complex filter coefficient set.
Default value is complex.
deint
Specify which frames to deinterlace. Accept one of the following values:
all Deinterlace all frames,
interlaced
Only deinterlace frames marked as interlaced.
Default value is all.
yadif
Deinterlace the input video ("yadif" means "yet another deinterlacing filter").
This filter accepts the following options:
mode
The interlacing mode to adopt, accepts one of the following values:
0, send_frame
output 1 frame for each frame
1, send_field
output 1 frame for each field
2, send_frame_nospatial
like "send_frame" but skip spatial interlacing check
3, send_field_nospatial
like "send_field" but skip spatial interlacing check
Default value is "send_frame".
parity
The picture field parity assumed for the input interlaced video, accepts one of the following values:
0, tff
assume top field first
1, bff
assume bottom field first
-1, auto
enable automatic detection
Default value is "auto". If interlacing is unknown or decoder does not export this information, top
field first will be assumed.
deint
Specify which frames to deinterlace. Accept one of the following values:
0, all
deinterlace all frames
1, interlaced
only deinterlace frames marked as interlaced
Default value is "all".
VIDEO SOURCES
Below is a description of the currently available video sources.
buffer
Buffer video frames, and make them available to the filter chain.
This source is mainly intended for a programmatic use, in particular through the interface defined in
libavfilter/vsrc_buffer.h.
This source accepts the following options:
video_size
Specify the size (width and height) of the buffered video frames. For the syntax of this option,
check the "Video size" section in the ffmpeg-utils manual.
width
Input video width.
height
Input video height.
pix_fmt
A string representing the pixel format of the buffered video frames. It may be a number
corresponding to a pixel format, or a pixel format name.
time_base
Specify the timebase assumed by the timestamps of the buffered frames.
frame_rate
Specify the frame rate expected for the video stream.
pixel_aspect, sar
Specify the sample aspect ratio assumed by the video frames.
sws_param
Specify the optional parameters to be used for the scale filter which is automatically inserted when
an input change is detected in the input size or format.
For example:
buffer=width=320:height=240:pix_fmt=yuv410p:time_base=1/24:sar=1
will instruct the source to accept video frames with size 320x240 and with format "yuv410p", assuming
1/24 as the timestamps timebase and square pixels (1:1 sample aspect ratio). Since the pixel format with
name "yuv410p" corresponds to the number 6 (check the enum AVPixelFormat definition in
libavutil/pixfmt.h), this example corresponds to:
buffer=size=320x240:pixfmt=6:time_base=1/24:pixel_aspect=1/1
Alternatively, the options can be specified as a flat string, but this syntax is deprecated:
width:height:pix_fmt:time_base.num:time_base.den:pixel_aspect.num:pixel_aspect.den[:sws_param]
cellauto
Create a pattern generated by an elementary cellular automaton.
The initial state of the cellular automaton can be defined through the filename, and pattern options. If
such options are not specified an initial state is created randomly.
At each new frame a new row in the video is filled with the result of the cellular automaton next
generation. The behavior when the whole frame is filled is defined by the scroll option.
This source accepts the following options:
filename, f
Read the initial cellular automaton state, i.e. the starting row, from the specified file. In the
file, each non-whitespace character is considered an alive cell, a newline will terminate the row,
and further characters in the file will be ignored.
pattern, p
Read the initial cellular automaton state, i.e. the starting row, from the specified string.
Each non-whitespace character in the string is considered an alive cell, a newline will terminate the
row, and further characters in the string will be ignored.
rate, r
Set the video rate, that is the number of frames generated per second. Default is 25.
random_fill_ratio, ratio
Set the random fill ratio for the initial cellular automaton row. It is a floating point number value
ranging from 0 to 1, defaults to 1/PHI.
This option is ignored when a file or a pattern is specified.
random_seed, seed
Set the seed for filling randomly the initial row, must be an integer included between 0 and
UINT32_MAX. If not specified, or if explicitly set to -1, the filter will try to use a good random
seed on a best effort basis.
rule
Set the cellular automaton rule, it is a number ranging from 0 to 255. Default value is 110.
size, s
Set the size of the output video. For the syntax of this option, check the "Video size" section in
the ffmpeg-utils manual.
If filename or pattern is specified, the size is set by default to the width of the specified initial
state row, and the height is set to width * PHI.
If size is set, it must contain the width of the specified pattern string, and the specified pattern
will be centered in the larger row.
If a filename or a pattern string is not specified, the size value defaults to "320x518" (used for a
randomly generated initial state).
scroll
If set to 1, scroll the output upward when all the rows in the output have been already filled. If
set to 0, the new generated row will be written over the top row just after the bottom row is filled.
Defaults to 1.
start_full, full
If set to 1, completely fill the output with generated rows before outputting the first frame. This
is the default behavior, for disabling set the value to 0.
stitch
If set to 1, stitch the left and right row edges together. This is the default behavior, for
disabling set the value to 0.
Examples
· Read the initial state from pattern, and specify an output of size 200x400.
cellauto=f=pattern:s=200x400
· Generate a random initial row with a width of 200 cells, with a fill ratio of 2/3:
cellauto=ratio=2/3:s=200x200
· Create a pattern generated by rule 18 starting by a single alive cell centered on an initial row with
width 100:
cellauto=p=@s=100x400:full=0:rule=18
· Specify a more elaborated initial pattern:
cellauto=p='@@ @ @@':s=100x400:full=0:rule=18
mandelbrot
Generate a Mandelbrot set fractal, and progressively zoom towards the point specified with start_x and
start_y.
This source accepts the following options:
end_pts
Set the terminal pts value. Default value is 400.
end_scale
Set the terminal scale value. Must be a floating point value. Default value is 0.3.
inner
Set the inner coloring mode, that is the algorithm used to draw the Mandelbrot fractal internal
region.
It shall assume one of the following values:
black
Set black mode.
convergence
Show time until convergence.
mincol
Set color based on point closest to the origin of the iterations.
period
Set period mode.
Default value is mincol.
bailout
Set the bailout value. Default value is 10.0.
maxiter
Set the maximum of iterations performed by the rendering algorithm. Default value is 7189.
outer
Set outer coloring mode. It shall assume one of following values:
iteration_count
Set iteration cound mode.
normalized_iteration_count
set normalized iteration count mode.
Default value is normalized_iteration_count.
rate, r
Set frame rate, expressed as number of frames per second. Default value is "25".
size, s
Set frame size. For the syntax of this option, check the "Video size" section in the ffmpeg-utils
manual. Default value is "640x480".
start_scale
Set the initial scale value. Default value is 3.0.
start_x
Set the initial x position. Must be a floating point value between -100 and 100. Default value is
-0.743643887037158704752191506114774.
start_y
Set the initial y position. Must be a floating point value between -100 and 100. Default value is
-0.131825904205311970493132056385139.
mptestsrc
Generate various test patterns, as generated by the MPlayer test filter.
The size of the generated video is fixed, and is 256x256. This source is useful in particular for
testing encoding features.
This source accepts the following options:
rate, r
Specify the frame rate of the sourced video, as the number of frames generated per second. It has to
be a string in the format frame_rate_num/frame_rate_den, an integer number, a float number or a valid
video frame rate abbreviation. The default value is "25".
duration, d
Set the video duration of the sourced video. The accepted syntax is:
[-]HH:MM:SS[.m...]
[-]S+[.m...]
See also the function "av_parse_time()".
If not specified, or the expressed duration is negative, the video is supposed to be generated
forever.
test, t
Set the number or the name of the test to perform. Supported tests are:
dc_luma
dc_chroma
freq_luma
freq_chroma
amp_luma
amp_chroma
cbp
mv
ring1
ring2
all
Default value is "all", which will cycle through the list of all tests.
For example the following:
testsrc=t=dc_luma
will generate a "dc_luma" test pattern.
frei0r_src
Provide a frei0r source.
To enable compilation of this filter you need to install the frei0r header and configure FFmpeg with
"--enable-frei0r".
This source accepts the following options:
size
The size of the video to generate. For the syntax of this option, check the "Video size" section in
the ffmpeg-utils manual.
framerate
Framerate of the generated video, may be a string of the form num/den or a frame rate abbreviation.
filter_name
The name to the frei0r source to load. For more information regarding frei0r and how to set the
parameters read the section frei0r in the description of the video filters.
filter_params
A '|'-separated list of parameters to pass to the frei0r source.
For example, to generate a frei0r partik0l source with size 200x200 and frame rate 10 which is overlayed
on the overlay filter main input:
frei0r_src=size=200x200:framerate=10:filter_name=partik0l:filter_params=1234 [overlay]; [in][overlay] overlay
life
Generate a life pattern.
This source is based on a generalization of John Conway's life game.
The sourced input represents a life grid, each pixel represents a cell which can be in one of two
possible states, alive or dead. Every cell interacts with its eight neighbours, which are the cells that
are horizontally, vertically, or diagonally adjacent.
At each interaction the grid evolves according to the adopted rule, which specifies the number of
neighbor alive cells which will make a cell stay alive or born. The rule option allows to specify the
rule to adopt.
This source accepts the following options:
filename, f
Set the file from which to read the initial grid state. In the file, each non-whitespace character is
considered an alive cell, and newline is used to delimit the end of each row.
If this option is not specified, the initial grid is generated randomly.
rate, r
Set the video rate, that is the number of frames generated per second. Default is 25.
random_fill_ratio, ratio
Set the random fill ratio for the initial random grid. It is a floating point number value ranging
from 0 to 1, defaults to 1/PHI. It is ignored when a file is specified.
random_seed, seed
Set the seed for filling the initial random grid, must be an integer included between 0 and
UINT32_MAX. If not specified, or if explicitly set to -1, the filter will try to use a good random
seed on a best effort basis.
rule
Set the life rule.
A rule can be specified with a code of the kind "SNS/BNB", where NS and NB are sequences of numbers
in the range 0-8, NS specifies the number of alive neighbor cells which make a live cell stay alive,
and NB the number of alive neighbor cells which make a dead cell to become alive (i.e. to "born").
"s" and "b" can be used in place of "S" and "B", respectively.
Alternatively a rule can be specified by an 18-bits integer. The 9 high order bits are used to encode
the next cell state if it is alive for each number of neighbor alive cells, the low order bits
specify the rule for "borning" new cells. Higher order bits encode for an higher number of neighbor
cells. For example the number 6153 = "(12<<9)+9" specifies a stay alive rule of 12 and a born rule
of 9, which corresponds to "S23/B03".
Default value is "S23/B3", which is the original Conway's game of life rule, and will keep a cell
alive if it has 2 or 3 neighbor alive cells, and will born a new cell if there are three alive cells
around a dead cell.
size, s
Set the size of the output video. For the syntax of this option, check the "Video size" section in
the ffmpeg-utils manual.
If filename is specified, the size is set by default to the same size of the input file. If size is
set, it must contain the size specified in the input file, and the initial grid defined in that file
is centered in the larger resulting area.
If a filename is not specified, the size value defaults to "320x240" (used for a randomly generated
initial grid).
stitch
If set to 1, stitch the left and right grid edges together, and the top and bottom edges also.
Defaults to 1.
mold
Set cell mold speed. If set, a dead cell will go from death_color to mold_color with a step of mold.
mold can have a value from 0 to 255.
life_color
Set the color of living (or new born) cells.
death_color
Set the color of dead cells. If mold is set, this is the first color used to represent a dead cell.
mold_color
Set mold color, for definitely dead and moldy cells.
For the syntax of these 3 color options, check the "Color" section in the ffmpeg-utils manual.
Examples
· Read a grid from pattern, and center it on a grid of size 300x300 pixels:
life=f=pattern:s=300x300
· Generate a random grid of size 200x200, with a fill ratio of 2/3:
life=ratio=2/3:s=200x200
· Specify a custom rule for evolving a randomly generated grid:
life=rule=S14/B34
· Full example with slow death effect (mold) using ffplay:
ffplay -f lavfi life=s=300x200:mold=10:r=60:ratio=0.1:death_color=#C83232:life_color=#00ff00,scale=1200:800:flags=16
color, haldclutsrc, nullsrc, rgbtestsrc, smptebars, smptehdbars, testsrc
The "color" source provides an uniformly colored input.
The "haldclutsrc" source provides an identity Hald CLUT. See also haldclut filter.
The "nullsrc" source returns unprocessed video frames. It is mainly useful to be employed in analysis /
debugging tools, or as the source for filters which ignore the input data.
The "rgbtestsrc" source generates an RGB test pattern useful for detecting RGB vs BGR issues. You should
see a red, green and blue stripe from top to bottom.
The "smptebars" source generates a color bars pattern, based on the SMPTE Engineering Guideline EG
1-1990.
The "smptehdbars" source generates a color bars pattern, based on the SMPTE RP 219-2002.
The "testsrc" source generates a test video pattern, showing a color pattern, a scrolling gradient and a
timestamp. This is mainly intended for testing purposes.
The sources accept the following options:
color, c
Specify the color of the source, only available in the "color" source. For the syntax of this option,
check the "Color" section in the ffmpeg-utils manual.
level
Specify the level of the Hald CLUT, only available in the "haldclutsrc" source. A level of "N"
generates a picture of "N*N*N" by "N*N*N" pixels to be used as identity matrix for 3D lookup tables.
Each component is coded on a "1/(N*N)" scale.
size, s
Specify the size of the sourced video. For the syntax of this option, check the "Video size" section
in the ffmpeg-utils manual. The default value is "320x240".
This option is not available with the "haldclutsrc" filter.
rate, r
Specify the frame rate of the sourced video, as the number of frames generated per second. It has to
be a string in the format frame_rate_num/frame_rate_den, an integer number, a float number or a valid
video frame rate abbreviation. The default value is "25".
sar Set the sample aspect ratio of the sourced video.
duration, d
Set the video duration of the sourced video. The accepted syntax is:
[-]HH[:MM[:SS[.m...]]]
[-]S+[.m...]
See also the function "av_parse_time()".
If not specified, or the expressed duration is negative, the video is supposed to be generated
forever.
decimals, n
Set the number of decimals to show in the timestamp, only available in the "testsrc" source.
The displayed timestamp value will correspond to the original timestamp value multiplied by the power
of 10 of the specified value. Default value is 0.
For example the following:
testsrc=duration=5.3:size=qcif:rate=10
will generate a video with a duration of 5.3 seconds, with size 176x144 and a frame rate of 10 frames per
second.
The following graph description will generate a red source with an opacity of 0.2, with size "qcif" and a
frame rate of 10 frames per second.
color=c=red@0.2:s=qcif:r=10
If the input content is to be ignored, "nullsrc" can be used. The following command generates noise in
the luminance plane by employing the "geq" filter:
nullsrc=s=256x256, geq=random(1)*255:128:128
Commands
The "color" source supports the following commands:
c, color
Set the color of the created image. Accepts the same syntax of the corresponding color option.
VIDEO SINKS
Below is a description of the currently available video sinks.
buffersink
Buffer video frames, and make them available to the end of the filter graph.
This sink is mainly intended for a programmatic use, in particular through the interface defined in
libavfilter/buffersink.h or the options system.
It accepts a pointer to an AVBufferSinkContext structure, which defines the incoming buffers' formats, to
be passed as the opaque parameter to "avfilter_init_filter" for initialization.
nullsink
Null video sink, do absolutely nothing with the input video. It is mainly useful as a template and to be
employed in analysis / debugging tools.
MULTIMEDIA FILTERS
Below is a description of the currently available multimedia filters.
avectorscope
Convert input audio to a video output, representing the audio vector scope.
The filter is used to measure the difference between channels of stereo audio stream. A monoaural signal,
consisting of identical left and right signal, results in straight vertical line. Any stereo separation
is visible as a deviation from this line, creating a Lissajous figure. If the straight (or deviation
from it) but horizontal line appears this indicates that the left and right channels are out of phase.
The filter accepts the following options:
mode, m
Set the vectorscope mode.
Available values are:
lissajous
Lissajous rotated by 45 degrees.
lissajous_xy
Same as above but not rotated.
Default value is lissajous.
size, s
Set the video size for the output. For the syntax of this option, check the "Video size" section in
the ffmpeg-utils manual. Default value is "400x400".
rate, r
Set the output frame rate. Default value is 25.
rc
gc
bc Specify the red, green and blue contrast. Default values are 40, 160 and 80. Allowed range is "[0,
255]".
rf
gf
bf Specify the red, green and blue fade. Default values are 15, 10 and 5. Allowed range is "[0, 255]".
zoom
Set the zoom factor. Default value is 1. Allowed range is "[1, 10]".
Examples
· Complete example using ffplay:
ffplay -f lavfi 'amovie=input.mp3, asplit [a][out1];
[a] avectorscope=zoom=1.3:rc=2:gc=200:bc=10:rf=1:gf=8:bf=7 [out0]'
concat
Concatenate audio and video streams, joining them together one after the other.
The filter works on segments of synchronized video and audio streams. All segments must have the same
number of streams of each type, and that will also be the number of streams at output.
The filter accepts the following options:
n Set the number of segments. Default is 2.
v Set the number of output video streams, that is also the number of video streams in each segment.
Default is 1.
a Set the number of output audio streams, that is also the number of video streams in each segment.
Default is 0.
unsafe
Activate unsafe mode: do not fail if segments have a different format.
The filter has v+a outputs: first v video outputs, then a audio outputs.
There are nx(v+a) inputs: first the inputs for the first segment, in the same order as the outputs, then
the inputs for the second segment, etc.
Related streams do not always have exactly the same duration, for various reasons including codec frame
size or sloppy authoring. For that reason, related synchronized streams (e.g. a video and its audio
track) should be concatenated at once. The concat filter will use the duration of the longest stream in
each segment (except the last one), and if necessary pad shorter audio streams with silence.
For this filter to work correctly, all segments must start at timestamp 0.
All corresponding streams must have the same parameters in all segments; the filtering system will
automatically select a common pixel format for video streams, and a common sample format, sample rate and
channel layout for audio streams, but other settings, such as resolution, must be converted explicitly by
the user.
Different frame rates are acceptable but will result in variable frame rate at output; be sure to
configure the output file to handle it.
Examples
· Concatenate an opening, an episode and an ending, all in bilingual version (video in stream 0, audio
in streams 1 and 2):
ffmpeg -i opening.mkv -i episode.mkv -i ending.mkv -filter_complex \
'[0:0] [0:1] [0:2] [1:0] [1:1] [1:2] [2:0] [2:1] [2:2]
concat=n=3:v=1:a=2 [v] [a1] [a2]' \
-map '[v]' -map '[a1]' -map '[a2]' output.mkv
· Concatenate two parts, handling audio and video separately, using the (a)movie sources, and adjusting
the resolution:
movie=part1.mp4, scale=512:288 [v1] ; amovie=part1.mp4 [a1] ;
movie=part2.mp4, scale=512:288 [v2] ; amovie=part2.mp4 [a2] ;
[v1] [v2] concat [outv] ; [a1] [a2] concat=v=0:a=1 [outa]
Note that a desync will happen at the stitch if the audio and video streams do not have exactly the
same duration in the first file.
ebur128
EBU R128 scanner filter. This filter takes an audio stream as input and outputs it unchanged. By default,
it logs a message at a frequency of 10Hz with the Momentary loudness (identified by "M"), Short-term
loudness ("S"), Integrated loudness ("I") and Loudness Range ("LRA").
The filter also has a video output (see the video option) with a real time graph to observe the loudness
evolution. The graphic contains the logged message mentioned above, so it is not printed anymore when
this option is set, unless the verbose logging is set. The main graphing area contains the short-term
loudness (3 seconds of analysis), and the gauge on the right is for the momentary loudness (400
milliseconds).
More information about the Loudness Recommendation EBU R128 on .
The filter accepts the following options:
video
Activate the video output. The audio stream is passed unchanged whether this option is set or no. The
video stream will be the first output stream if activated. Default is 0.
size
Set the video size. This option is for video only. For the syntax of this option, check the "Video
size" section in the ffmpeg-utils manual. Default and minimum resolution is "640x480".
meter
Set the EBU scale meter. Default is 9. Common values are 9 and 18, respectively for EBU scale meter
+9 and EBU scale meter +18. Any other integer value between this range is allowed.
metadata
Set metadata injection. If set to 1, the audio input will be segmented into 100ms output frames, each
of them containing various loudness information in metadata. All the metadata keys are prefixed with
"lavfi.r128.".
Default is 0.
framelog
Force the frame logging level.
Available values are:
info
information logging level
verbose
verbose logging level
By default, the logging level is set to info. If the video or the metadata options are set, it
switches to verbose.
peak
Set peak mode(s).
Available modes can be cumulated (the option is a "flag" type). Possible values are:
none
Disable any peak mode (default).
sample
Enable sample-peak mode.
Simple peak mode looking for the higher sample value. It logs a message for sample-peak
(identified by "SPK").
true
Enable true-peak mode.
If enabled, the peak lookup is done on an over-sampled version of the input stream for better
peak accuracy. It logs a message for true-peak. (identified by "TPK") and true-peak per frame
(identified by "FTPK"). This mode requires a build with "libswresample".
Examples
· Real-time graph using ffplay, with a EBU scale meter +18:
ffplay -f lavfi -i "amovie=input.mp3,ebur128=video=1:meter=18 [out0][out1]"
· Run an analysis with ffmpeg:
ffmpeg -nostats -i input.mp3 -filter_complex ebur128 -f null -
interleave, ainterleave
Temporally interleave frames from several inputs.
"interleave" works with video inputs, "ainterleave" with audio.
These filters read frames from several inputs and send the oldest queued frame to the output.
Input streams must have a well defined, monotonically increasing frame timestamp values.
In order to submit one frame to output, these filters need to enqueue at least one frame for each input,
so they cannot work in case one input is not yet terminated and will not receive incoming frames.
For example consider the case when one input is a "select" filter which always drop input frames. The
"interleave" filter will keep reading from that input, but it will never be able to send new frames to
output until the input will send an end-of-stream signal.
Also, depending on inputs synchronization, the filters will drop frames in case one input receives more
frames than the other ones, and the queue is already filled.
These filters accept the following options:
nb_inputs, n
Set the number of different inputs, it is 2 by default.
Examples
· Interleave frames belonging to different streams using ffmpeg:
ffmpeg -i bambi.avi -i pr0n.mkv -filter_complex "[0:v][1:v] interleave" out.avi
· Add flickering blur effect:
select='if(gt(random(0), 0.2), 1, 2)':n=2 [tmp], boxblur=2:2, [tmp] interleave
perms, aperms
Set read/write permissions for the output frames.
These filters are mainly aimed at developers to test direct path in the following filter in the
filtergraph.
The filters accept the following options:
mode
Select the permissions mode.
It accepts the following values:
none
Do nothing. This is the default.
ro Set all the output frames read-only.
rw Set all the output frames directly writable.
toggle
Make the frame read-only if writable, and writable if read-only.
random
Set each output frame read-only or writable randomly.
seed
Set the seed for the random mode, must be an integer included between 0 and "UINT32_MAX". If not
specified, or if explicitly set to "-1", the filter will try to use a good random seed on a best
effort basis.
Note: in case of auto-inserted filter between the permission filter and the following one, the permission
might not be received as expected in that following filter. Inserting a format or aformat filter before
the perms/aperms filter can avoid this problem.
select, aselect
Select frames to pass in output.
This filter accepts the following options:
expr, e
Set expression, which is evaluated for each input frame.
If the expression is evaluated to zero, the frame is discarded.
If the evaluation result is negative or NaN, the frame is sent to the first output; otherwise it is
sent to the output with index "ceil(val)-1", assuming that the input index starts from 0.
For example a value of 1.2 corresponds to the output with index "ceil(1.2)-1 = 2-1 = 1", that is the
second output.
outputs, n
Set the number of outputs. The output to which to send the selected frame is based on the result of
the evaluation. Default value is 1.
The expression can contain the following constants:
n the sequential number of the filtered frame, starting from 0
selected_n
the sequential number of the selected frame, starting from 0
prev_selected_n
the sequential number of the last selected frame, NAN if undefined
TB timebase of the input timestamps
pts the PTS (Presentation TimeStamp) of the filtered video frame, expressed in TB units, NAN if undefined
t the PTS (Presentation TimeStamp) of the filtered video frame, expressed in seconds, NAN if undefined
prev_pts
the PTS of the previously filtered video frame, NAN if undefined
prev_selected_pts
the PTS of the last previously filtered video frame, NAN if undefined
prev_selected_t
the PTS of the last previously selected video frame, NAN if undefined
start_pts
the PTS of the first video frame in the video, NAN if undefined
start_t
the time of the first video frame in the video, NAN if undefined
pict_type (video only)
the type of the filtered frame, can assume one of the following values:
I
P
B
S
SI
SP
BI
interlace_type (video only)
the frame interlace type, can assume one of the following values:
PROGRESSIVE
the frame is progressive (not interlaced)
TOPFIRST
the frame is top-field-first
BOTTOMFIRST
the frame is bottom-field-first
consumed_sample_n (audio only)
the number of selected samples before the current frame
samples_n (audio only)
the number of samples in the current frame
sample_rate (audio only)
the input sample rate
key 1 if the filtered frame is a key-frame, 0 otherwise
pos the position in the file of the filtered frame, -1 if the information is not available (e.g. for
synthetic video)
scene (video only)
value between 0 and 1 to indicate a new scene; a low value reflects a low probability for the current
frame to introduce a new scene, while a higher value means the current frame is more likely to be one
(see the example below)
The default value of the select expression is "1".
Examples
· Select all frames in input:
select
The example above is the same as:
select=1
· Skip all frames:
select=0
· Select only I-frames:
select='eq(pict_type\,I)'
· Select one frame every 100:
select='not(mod(n\,100))'
· Select only frames contained in the 10-20 time interval:
select=between(t\,10\,20)
· Select only I frames contained in the 10-20 time interval:
select=between(t\,10\,20)*eq(pict_type\,I)
· Select frames with a minimum distance of 10 seconds:
select='isnan(prev_selected_t)+gte(t-prev_selected_t\,10)'
· Use aselect to select only audio frames with samples number > 100:
aselect='gt(samples_n\,100)'
· Create a mosaic of the first scenes:
ffmpeg -i video.avi -vf select='gt(scene\,0.4)',scale=160:120,tile -frames:v 1 preview.png
Comparing scene against a value between 0.3 and 0.5 is generally a sane choice.
· Send even and odd frames to separate outputs, and compose them:
select=n=2:e='mod(n, 2)+1' [odd][even]; [odd] pad=h=2*ih [tmp]; [tmp][even] overlay=y=h
sendcmd, asendcmd
Send commands to filters in the filtergraph.
These filters read commands to be sent to other filters in the filtergraph.
"sendcmd" must be inserted between two video filters, "asendcmd" must be inserted between two audio
filters, but apart from that they act the same way.
The specification of commands can be provided in the filter arguments with the commands option, or in a
file specified by the filename option.
These filters accept the following options:
commands, c
Set the commands to be read and sent to the other filters.
filename, f
Set the filename of the commands to be read and sent to the other filters.
Commands syntax
A commands description consists of a sequence of interval specifications, comprising a list of commands
to be executed when a particular event related to that interval occurs. The occurring event is typically
the current frame time entering or leaving a given time interval.
An interval is specified by the following syntax:
[-] ;
The time interval is specified by the START and END times. END is optional and defaults to the maximum
time.
The current frame time is considered within the specified interval if it is included in the interval
[START, END), that is when the time is greater or equal to START and is lesser than END.
COMMANDS consists of a sequence of one or more command specifications, separated by ",", relating to that
interval. The syntax of a command specification is given by:
[]
FLAGS is optional and specifies the type of events relating to the time interval which enable sending the
specified command, and must be a non-null sequence of identifier flags separated by "+" or "|" and
enclosed between "[" and "]".
The following flags are recognized:
enter
The command is sent when the current frame timestamp enters the specified interval. In other words,
the command is sent when the previous frame timestamp was not in the given interval, and the current
is.
leave
The command is sent when the current frame timestamp leaves the specified interval. In other words,
the command is sent when the previous frame timestamp was in the given interval, and the current is
not.
If FLAGS is not specified, a default value of "[enter]" is assumed.
TARGET specifies the target of the command, usually the name of the filter class or a specific filter
instance name.
COMMAND specifies the name of the command for the target filter.
ARG is optional and specifies the optional list of argument for the given COMMAND.
Between one interval specification and another, whitespaces, or sequences of characters starting with "#"
until the end of line, are ignored and can be used to annotate comments.
A simplified BNF description of the commands specification syntax follows:
::= "enter" | "leave"
::= [(+|"|")]
::= ["[" "]"] []
::= [,]
::= [-]
::= [;]
Examples
· Specify audio tempo change at second 4:
asendcmd=c='4.0 atempo tempo 1.5',atempo
· Specify a list of drawtext and hue commands in a file.
# show text in the interval 5-10
5.0-10.0 [enter] drawtext reinit 'fontfile=FreeSerif.ttf:text=hello world',
[leave] drawtext reinit 'fontfile=FreeSerif.ttf:text=';
# desaturate the image in the interval 15-20
15.0-20.0 [enter] hue s 0,
[enter] drawtext reinit 'fontfile=FreeSerif.ttf:text=nocolor',
[leave] hue s 1,
[leave] drawtext reinit 'fontfile=FreeSerif.ttf:text=color';
# apply an exponential saturation fade-out effect, starting from time 25
25 [enter] hue s exp(25-t)
A filtergraph allowing to read and process the above command list stored in a file test.cmd, can be
specified with:
sendcmd=f=test.cmd,drawtext=fontfile=FreeSerif.ttf:text='',hue
setpts, asetpts
Change the PTS (presentation timestamp) of the input frames.
"setpts" works on video frames, "asetpts" on audio frames.
This filter accepts the following options:
expr
The expression which is evaluated for each frame to construct its timestamp.
The expression is evaluated through the eval API and can contain the following constants:
FRAME_RATE
frame rate, only defined for constant frame-rate video
PTS the presentation timestamp in input
N the count of the input frame for video or the number of consumed samples, not including the current
frame for audio, starting from 0.
NB_CONSUMED_SAMPLES
the number of consumed samples, not including the current frame (only audio)
NB_SAMPLES, S
the number of samples in the current frame (only audio)
SAMPLE_RATE, SR
audio sample rate
STARTPTS
the PTS of the first frame
STARTT
the time in seconds of the first frame
INTERLACED
tell if the current frame is interlaced
T the time in seconds of the current frame
POS original position in the file of the frame, or undefined if undefined for the current frame
PREV_INPTS
previous input PTS
PREV_INT
previous input time in seconds
PREV_OUTPTS
previous output PTS
PREV_OUTT
previous output time in seconds
RTCTIME
wallclock (RTC) time in microseconds. This is deprecated, use time(0) instead.
RTCSTART
wallclock (RTC) time at the start of the movie in microseconds
TB timebase of the input timestamps
Examples
· Start counting PTS from zero
setpts=PTS-STARTPTS
· Apply fast motion effect:
setpts=0.5*PTS
· Apply slow motion effect:
setpts=2.0*PTS
· Set fixed rate of 25 frames per second:
setpts=N/(25*TB)
· Set fixed rate 25 fps with some jitter:
setpts='1/(25*TB) * (N + 0.05 * sin(N*2*PI/25))'
· Apply an offset of 10 seconds to the input PTS:
setpts=PTS+10/TB
· Generate timestamps from a "live source" and rebase onto the current timebase:
setpts='(RTCTIME - RTCSTART) / (TB * 1000000)'
· Generate timestamps by counting samples:
asetpts=N/SR/TB
settb, asettb
Set the timebase to use for the output frames timestamps. It is mainly useful for testing timebase
configuration.
This filter accepts the following options:
expr, tb
The expression which is evaluated into the output timebase.
The value for tb is an arithmetic expression representing a rational. The expression can contain the
constants "AVTB" (the default timebase), "intb" (the input timebase) and "sr" (the sample rate, audio
only). Default value is "intb".
Examples
· Set the timebase to 1/25:
settb=expr=1/25
· Set the timebase to 1/10:
settb=expr=0.1
· Set the timebase to 1001/1000:
settb=1+0.001
· Set the timebase to 2*intb:
settb=2*intb
· Set the default timebase value:
settb=AVTB
showspectrum
Convert input audio to a video output, representing the audio frequency spectrum.
The filter accepts the following options:
size, s
Specify the video size for the output. For the syntax of this option, check the "Video size" section
in the ffmpeg-utils manual. Default value is "640x512".
slide
Specify if the spectrum should slide along the window. Default value is 0.
mode
Specify display mode.
It accepts the following values:
combined
all channels are displayed in the same row
separate
all channels are displayed in separate rows
Default value is combined.
color
Specify display color mode.
It accepts the following values:
channel
each channel is displayed in a separate color
intensity
each channel is is displayed using the same color scheme
Default value is channel.
scale
Specify scale used for calculating intensity color values.
It accepts the following values:
lin linear
sqrt
square root, default
cbrt
cubic root
log logarithmic
Default value is sqrt.
saturation
Set saturation modifier for displayed colors. Negative values provide alternative color scheme. 0 is
no saturation at all. Saturation must be in [-10.0, 10.0] range. Default value is 1.
win_func
Set window function.
It accepts the following values:
none
No samples pre-processing (do not expect this to be faster)
hann
Hann window
hamming
Hamming window
blackman
Blackman window
Default value is "hann".
The usage is very similar to the showwaves filter; see the examples in that section.
Examples
· Large window with logarithmic color scaling:
showspectrum=s=1280x480:scale=log
· Complete example for a colored and sliding spectrum per channel using ffplay:
ffplay -f lavfi 'amovie=input.mp3, asplit [a][out1];
[a] showspectrum=mode=separate:color=intensity:slide=1:scale=cbrt [out0]'
showwaves
Convert input audio to a video output, representing the samples waves.
The filter accepts the following options:
size, s
Specify the video size for the output. For the syntax of this option, check the "Video size" section
in the ffmpeg-utils manual. Default value is "600x240".
mode
Set display mode.
Available values are:
point
Draw a point for each sample.
line
Draw a vertical line for each sample.
Default value is "point".
n Set the number of samples which are printed on the same column. A larger value will decrease the
frame rate. Must be a positive integer. This option can be set only if the value for rate is not
explicitly specified.
rate, r
Set the (approximate) output frame rate. This is done by setting the option n. Default value is "25".
Examples
· Output the input file audio and the corresponding video representation at the same time:
amovie=a.mp3,asplit[out0],showwaves[out1]
· Create a synthetic signal and show it with showwaves, forcing a frame rate of 30 frames per second:
aevalsrc=sin(1*2*PI*t)*sin(880*2*PI*t):cos(2*PI*200*t),asplit[out0],showwaves=r=30[out1]
split, asplit
Split input into several identical outputs.
"asplit" works with audio input, "split" with video.
The filter accepts a single parameter which specifies the number of outputs. If unspecified, it defaults
to 2.
Examples
· Create two separate outputs from the same input:
[in] split [out0][out1]
· To create 3 or more outputs, you need to specify the number of outputs, like in:
[in] asplit=3 [out0][out1][out2]
· Create two separate outputs from the same input, one cropped and one padded:
[in] split [splitout1][splitout2];
[splitout1] crop=100:100:0:0 [cropout];
[splitout2] pad=200:200:100:100 [padout];
· Create 5 copies of the input audio with ffmpeg:
ffmpeg -i INPUT -filter_complex asplit=5 OUTPUT
zmq, azmq
Receive commands sent through a libzmq client, and forward them to filters in the filtergraph.
"zmq" and "azmq" work as a pass-through filters. "zmq" must be inserted between two video filters, "azmq"
between two audio filters.
To enable these filters you need to install the libzmq library and headers and configure FFmpeg with
"--enable-libzmq".
For more information about libzmq see:
The "zmq" and "azmq" filters work as a libzmq server, which receives messages sent through a network
interface defined by the bind_address option.
The received message must be in the form:
[]
TARGET specifies the target of the command, usually the name of the filter class or a specific filter
instance name.
COMMAND specifies the name of the command for the target filter.
ARG is optional and specifies the optional argument list for the given COMMAND.
Upon reception, the message is processed and the corresponding command is injected into the filtergraph.
Depending on the result, the filter will send a reply to the client, adopting the format:
MESSAGE is optional.
Examples
Look at tools/zmqsend for an example of a zmq client which can be used to send commands processed by
these filters.
Consider the following filtergraph generated by ffplay
ffplay -dumpgraph 1 -f lavfi "
color=s=100x100:c=red [l];
color=s=100x100:c=blue [r];
nullsrc=s=200x100, zmq [bg];
[bg][l] overlay [bg+l];
[bg+l][r] overlay=x=100 "
To change the color of the left side of the video, the following command can be used:
echo Parsed_color_0 c yellow | tools/zmqsend
To change the right side:
echo Parsed_color_1 c pink | tools/zmqsend
MULTIMEDIA SOURCES
Below is a description of the currently available multimedia sources.
amovie
This is the same as movie source, except it selects an audio stream by default.
movie
Read audio and/or video stream(s) from a movie container.
This filter accepts the following options:
filename
The name of the resource to read (not necessarily a file but also a device or a stream accessed
through some protocol).
format_name, f
Specifies the format assumed for the movie to read, and can be either the name of a container or an
input device. If not specified the format is guessed from movie_name or by probing.
seek_point, sp
Specifies the seek point in seconds, the frames will be output starting from this seek point, the
parameter is evaluated with "av_strtod" so the numerical value may be suffixed by an IS postfix.
Default value is "0".
streams, s
Specifies the streams to read. Several streams can be specified, separated by "+". The source will
then have as many outputs, in the same order. The syntax is explained in the ``Stream specifiers''
section in the ffmpeg manual. Two special names, "dv" and "da" specify respectively the default (best
suited) video and audio stream. Default is "dv", or "da" if the filter is called as "amovie".
stream_index, si
Specifies the index of the video stream to read. If the value is -1, the best suited video stream
will be automatically selected. Default value is "-1". Deprecated. If the filter is called "amovie",
it will select audio instead of video.
loop
Specifies how many times to read the stream in sequence. If the value is less than 1, the stream
will be read again and again. Default value is "1".
Note that when the movie is looped the source timestamps are not changed, so it will generate non
monotonically increasing timestamps.
This filter allows to overlay a second video on top of main input of a filtergraph as shown in this
graph:
input -----------> deltapts0 --> overlay --> output
^
|
movie --> scale--> deltapts1 -------+
Examples
· Skip 3.2 seconds from the start of the avi file in.avi, and overlay it on top of the input labelled
as "in":
movie=in.avi:seek_point=3.2, scale=180:-1, setpts=PTS-STARTPTS [over];
[in] setpts=PTS-STARTPTS [main];
[main][over] overlay=16:16 [out]
· Read from a video4linux2 device, and overlay it on top of the input labelled as "in":
movie=/dev/video0:f=video4linux2, scale=180:-1, setpts=PTS-STARTPTS [over];
[in] setpts=PTS-STARTPTS [main];
[main][over] overlay=16:16 [out]
· Read the first video stream and the audio stream with id 0x81 from dvd.vob; the video is connected to
the pad named "video" and the audio is connected to the pad named "audio":
movie=dvd.vob:s=v:0+#0x81 [video] [audio]
SEE ALSO
ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), ffmpeg-utils(1), ffmpeg-scaler(1), ffmpeg-resampler(1),
ffmpeg-codecs(1), ffmpeg-bitstream-filters(1), ffmpeg-formats(1), ffmpeg-devices(1), ffmpeg-protocols(1),
ffmpeg-filters(1)
AUTHORS
The FFmpeg developers.
For details about the authorship, see the Git history of the project (git://source.ffmpeg.org/ffmpeg),
e.g. by typing the command git log in the FFmpeg source directory, or browsing the online repository at
.
Maintainers for the specific components are listed in the file MAINTAINERS in the source code tree.
2014-04-11 FFMPEG-ALL(1)