Merge commit '7536c671040f1f3ebc9f0d3b7831dac71436b775'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 23:14:01 +0000 (01:14 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 23:18:18 +0000 (01:18 +0200)
* commit '7536c671040f1f3ebc9f0d3b7831dac71436b775':
  vf_yadif: switch to an AVOptions-based system.

Conflicts:
doc/filters.texi
libavfilter/vf_yadif.c
libavfilter/yadif.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
doc/filters.texi
libavfilter/avfilter.c
libavfilter/vf_yadif.c

@@@ -5540,849 -1178,568 +5540,845 @@@ This filter accepts the following optio
  
  @table @option
  
 -@item 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.
 +@item dir
 +The direction of the transpose.
  
 -@item 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.
 +@table @samp
 +@item 0, 4, cclock_flip
 +Rotate by 90 degrees counterclockwise and vertically flip (default), that is:
 +@example
 +L.R     L.l
 +. . ->  . .
 +l.r     R.r
 +@end example
  
 -@end table
 +@item 1, 5, clock
 +Rotate by 90 degrees clockwise, that is:
 +@example
 +L.R     l.L
 +. . ->  . .
 +l.r     r.R
 +@end example
  
 +@item 2, 6, cclock
 +Rotate by 90 degrees counterclockwise, that is:
  @example
 -# default parameters
 -gradfun=strength=1.2:radius=16
 +L.R     R.r
 +. . ->  . .
 +l.r     L.l
 +@end example
  
 -# omitting radius
 -gradfun=1.2
 +@item 3, 7, clock_flip
 +Rotate by 90 degrees clockwise and vertically flip, that is:
 +@example
 +L.R     r.R
 +. . ->  . .
 +l.r     l.L
  @end example
 +@end table
  
 -@section hflip
 +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 @code{passthrough} option should be used instead.
  
 -Flip the input video horizontally.
 +@item passthrough
 +Do not apply the transposition if the input geometry matches the one
 +specified by the specified value. It accepts the following values:
 +@table @samp
 +@item none
 +Always apply transposition.
 +@item portrait
 +Preserve portrait geometry (when @var{height} >= @var{width}).
 +@item landscape
 +Preserve landscape geometry (when @var{width} >= @var{height}).
 +@end table
 +
 +Default value is @code{none}.
 +@end table
  
 -For example to horizontally flip the input video with @command{avconv}:
 +For example to rotate by 90 degrees clockwise and preserve portrait
 +layout:
  @example
 -avconv -i in.avi -vf "hflip" out.avi
 +transpose=dir=1:passthrough=portrait
  @end example
  
 -@section 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:
 +The command above can also be specified as:
 +@example
 +transpose=1:portrait
 +@end example
  
 -@table @option
 -@item luma_spatial
 -a non-negative float number which specifies spatial luma strength,
 -defaults to 4.0
 +@section unsharp
  
 -@item chroma_spatial
 -a non-negative float number which specifies spatial chroma strength,
 -defaults to 3.0*@var{luma_spatial}/4.0
 +Sharpen or blur the input video.
  
 -@item luma_tmp
 -a float number which specifies luma temporal strength, defaults to
 -6.0*@var{luma_spatial}/4.0
 +It accepts the following parameters:
  
 -@item chroma_tmp
 -a float number which specifies chroma temporal strength, defaults to
 -@var{luma_tmp}*@var{chroma_spatial}/@var{luma_spatial}
 +@table @option
 +@item luma_msize_x, lx
 +@item chroma_msize_x, cx
 +Set the luma/chroma matrix horizontal size. It must be an odd integer
 +between 3 and 63, default value is 5.
 +
 +@item luma_msize_y, ly
 +@item chroma_msize_y, cy
 +Set the luma/chroma matrix vertical size. It must be an odd integer
 +between 3 and 63, default value is 5.
 +
 +@item luma_amount, la
 +@item chroma_amount, ca
 +Set the luma/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 1.0 for @option{luma_amount}, 0.0 for
 +@option{chroma_amount}.
  @end table
  
 -@section lut, lutrgb, lutyuv
 +All parameters are optional and default to the
 +equivalent of the string '5:5:1.0:5:5:0.0'.
  
 -Compute a look-up table for binding each pixel component input value
 -to an output value, and apply it to input video.
 +@subsection Examples
  
 -@var{lutyuv} applies a lookup table to a YUV input video, @var{lutrgb}
 -to an RGB input video.
 +@itemize
 +@item
 +Apply strong luma sharpen effect:
 +@example
 +unsharp=luma_msize_x=7:luma_msize_y=7:luma_amount=2.5
 +@end example
  
 -These filters accept the following options:
 -@table @option
 -@item @var{c0} (first  pixel component)
 -@item @var{c1} (second pixel component)
 -@item @var{c2} (third  pixel component)
 -@item @var{c3} (fourth pixel component, corresponds to the alpha component)
 +@item
 +Apply strong blur of both luma and chroma parameters:
 +@example
 +unsharp=7:7:-2:7:7:-2
 +@end example
 +@end itemize
  
 -@item @var{r} (red component)
 -@item @var{g} (green component)
 -@item @var{b} (blue component)
 -@item @var{a} (alpha component)
 +@section vflip
  
 -@item @var{y} (Y/luminance component)
 -@item @var{u} (U/Cb component)
 -@item @var{v} (V/Cr component)
 -@end table
 +Flip the input video vertically.
  
 -Each of them specifies the expression to use for computing the lookup table for
 -the corresponding pixel component values.
 +@example
 +ffmpeg -i in.avi -vf "vflip" out.avi
 +@end example
  
 -The exact component associated to each of the @var{c*} options depends on the
 -format in input.
 +@section yadif
  
 -The @var{lut} filter requires either YUV or RGB pixel formats in input,
 -@var{lutrgb} requires RGB pixel formats in input, and @var{lutyuv} requires YUV.
 +Deinterlace the input video ("yadif" means "yet another deinterlacing
 +filter").
  
- The filter accepts parameters as a list of @var{key}=@var{value}
- pairs, separated by ":". If the key of the first options is omitted,
- the arguments are interpreted according to syntax
- @var{mode}:@var{parity}:@var{deint}.
 -The expressions can contain the following constants and functions:
++This filter accepts the following options:
  
- The description of the accepted parameters follows.
 -@table @option
 -@item E, PI, PHI
 -the corresponding mathematical approximated values for e
 -(euler number), pi (greek PI), PHI (golden ratio)
  
 -@item w, h
 -the input width and height
 +@table @option
 -@item val
 -input value for the pixel component
 +@item mode
- Specify the interlacing mode to adopt. Accept one of the following
- values:
++The interlacing mode to adopt, accepts one of the following values:
  
 -@item clipval
 -the input value clipped in the @var{minval}-@var{maxval} range
 +@table @option
 +@item 0, send_frame
 +output 1 frame for each frame
 +@item 1, send_field
 +output 1 frame for each field
 +@item 2, send_frame_nospatial
 +like @code{send_frame} but skip spatial interlacing check
 +@item 3, send_field_nospatial
 +like @code{send_field} but skip spatial interlacing check
 +@end table
  
 -@item maxval
 -maximum value for the pixel component
 +Default value is @code{send_frame}.
  
 -@item minval
 -minimum value for the pixel component
 +@item parity
- Specify the picture field parity assumed for the input interlaced
- video. Accept one of the following values:
++The picture field parity assumed for the input interlaced video, accepts one of
++the following values:
  
 -@item negval
 -the negated value for the pixel component value clipped in the
 -@var{minval}-@var{maxval} range , it corresponds to the expression
 -"maxval-clipval+minval"
 +@table @option
 +@item 0, tff
 +assume top field first
 +@item 1, bff
 +assume bottom field first
 +@item -1, auto
 +enable automatic detection
 +@end table
  
 -@item clip(val)
 -the computed value in @var{val} clipped in the
 -@var{minval}-@var{maxval} range
 +Default value is @code{auto}.
 +If interlacing is unknown or decoder does not export this information,
 +top field first will be assumed.
  
 -@item gammaval(gamma)
 -the computed gamma correction value of the pixel component value
 -clipped in the @var{minval}-@var{maxval} range, corresponds to the
 -expression
 -"pow((clipval-minval)/(maxval-minval)\,@var{gamma})*(maxval-minval)+minval"
 +@item deint
 +Specify which frames to deinterlace. Accept one of the following
 +values:
  
 +@table @option
 +@item 0, all
 +deinterlace all frames
 +@item 1, interlaced
 +only deinterlace frames marked as interlaced
  @end table
  
 -All expressions default to "val".
 -
 -Some examples follow:
 -@example
 -# 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"
 +Default value is @code{all}.
 +@end table
  
 -# negate luminance
 -lutyuv=negval
 +@c man end VIDEO FILTERS
  
 -# remove chroma components, turns the video into a graytone image
 -lutyuv="u=128:v=128"
 +@chapter Video Sources
 +@c man begin VIDEO SOURCES
  
 -# apply a luma burning effect
 -lutyuv="y=2*val"
 +Below is a description of the currently available video sources.
  
 -# remove green and blue components
 -lutrgb="g=0:b=0"
 +@section buffer
  
 -# set a constant alpha channel value on input
 -format=rgba,lutrgb=a="maxval-minval/2"
 +Buffer video frames, and make them available to the filter chain.
  
 -# correct luminance gamma by a 0.5 factor
 -lutyuv=y=gammaval(0.5)
 -@end example
 +This source is mainly intended for a programmatic use, in particular
 +through the interface defined in @file{libavfilter/vsrc_buffer.h}.
  
 -@section negate
 +It accepts a list of options in the form of @var{key}=@var{value} pairs
 +separated by ":". A description of the accepted options follows.
  
 -Negate input video.
 +@table @option
  
 -This filter accepts an integer in input, if non-zero it negates the
 -alpha component (if available). The default value in input is 0.
 +@item video_size
 +Specify the size (width and height) of the buffered video frames.
  
 -@section noformat
 +@item 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.
  
 -Force libavfilter not to use any of the specified pixel formats for the
 -input to the next filter.
 +@item time_base
 +Specify the timebase assumed by the timestamps of the buffered frames.
  
 -This filter accepts the following parameters:
 -@table @option
 +@item time_base
 +Specify the frame rate expected for the video stream.
  
 -@item pix_fmts
 -A '|'-separated list of pixel format names, for example
 -"pix_fmts=yuv420p|monow|rgb24".
 +@item pixel_aspect
 +Specify the sample aspect ratio assumed by the video frames.
  
 +@item 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.
  @end table
  
 -Some examples follow:
 +For example:
  @example
 -# force libavfilter to use a format different from "yuv420p" for the
 -# input to the vflip filter
 -noformat=pix_fmts=yuv420p,vflip
 +buffer=size=320x240:pix_fmt=yuv410p:time_base=1/24:pixel_aspect=1/1
 +@end example
  
 -# convert the input video to any of the formats not contained in the list
 -noformat=yuv420p|yuv444p|yuv410p
 +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 @file{libavutil/pixfmt.h}),
 +this example corresponds to:
 +@example
 +buffer=size=320x240:pixfmt=6:time_base=1/24:pixel_aspect=1/1
  @end example
  
 -@section null
 +Alternatively, the options can be specified as a flat string, but this
 +syntax is deprecated:
  
 -Pass the video source unchanged to the output.
 +@var{width}:@var{height}:@var{pix_fmt}:@var{time_base.num}:@var{time_base.den}:@var{pixel_aspect.num}:@var{pixel_aspect.den}[:@var{sws_param}]
  
 -@section ocv
 +@section cellauto
  
 -Apply video transform using libopencv.
 +Create a pattern generated by an elementary cellular automaton.
  
 -To enable this filter install libopencv library and headers and
 -configure Libav with --enable-libopencv.
 +The initial state of the cellular automaton can be defined through the
 +@option{filename}, and @option{pattern} options. If such options are
 +not specified an initial state is created randomly.
  
 -This filter accepts the following parameters:
 +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 @option{scroll} option.
 +
 +This source accepts the following options:
  
  @table @option
 +@item 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.
  
 -@item filter_name
 -The name of the libopencv filter to apply.
 +@item pattern, p
 +Read the initial cellular automaton state, i.e. the starting row, from
 +the specified string.
  
 -@item filter_params
 -The parameters to pass to the libopencv filter. If not specified the default
 -values are assumed.
 +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.
  
 -@end table
 +@item rate, r
 +Set the video rate, that is the number of frames generated per second.
 +Default is 25.
  
 -Refer to the official libopencv documentation for more precise
 -information:
 -@url{http://opencv.willowgarage.com/documentation/c/image_filtering.html}
 +@item 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.
  
 -Follows the list of supported libopencv filters.
 +This option is ignored when a file or a pattern is specified.
  
 -@anchor{dilate}
 -@subsection dilate
 +@item 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.
  
 -Dilate an image by using a specific structuring element.
 -This filter corresponds to the libopencv function @code{cvDilate}.
 +@item rule
 +Set the cellular automaton rule, it is a number ranging from 0 to 255.
 +Default value is 110.
  
 -It accepts the parameters: @var{struct_el}|@var{nb_iterations}.
 +@item size, s
 +Set the size of the output video.
  
 -@var{struct_el} represents a structuring element, and has the syntax:
 -@var{cols}x@var{rows}+@var{anchor_x}x@var{anchor_y}/@var{shape}
 +If @option{filename} or @option{pattern} is specified, the size is set
 +by default to the width of the specified initial state row, and the
 +height is set to @var{width} * PHI.
  
 -@var{cols} and @var{rows} represent the number of columns and rows of
 -the structuring element, @var{anchor_x} and @var{anchor_y} the anchor
 -point, and @var{shape} the shape for the structuring element, and
 -can be one of the values "rect", "cross", "ellipse", "custom".
 +If @option{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 the value for @var{shape} is "custom", it must be followed by a
 -string of the form "=@var{filename}". The file with name
 -@var{filename} is assumed to represent a binary image, with each
 -printable character corresponding to a bright pixel. When a custom
 -@var{shape} is used, @var{cols} and @var{rows} are ignored, the number
 -or columns and rows of the read file are assumed instead.
 +If a filename or a pattern string is not specified, the size value
 +defaults to "320x518" (used for a randomly generated initial state).
  
 -The default value for @var{struct_el} is "3x3+0x0/rect".
 +@item 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.
  
 -@var{nb_iterations} specifies the number of times the transform is
 -applied to the image, and defaults to 1.
 +@item 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.
  
 -Follow some example:
 -@example
 -# use the default values
 -ocv=dilate
 +@item 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.
 +@end table
  
 -# dilate using a structuring element with a 5x5 cross, iterate two times
 -ocv=filter_name=dilate:filter_params=5x5+2x2/cross|2
 +@subsection Examples
  
 -# 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
 +@itemize
 +@item
 +Read the initial state from @file{pattern}, and specify an output of
 +size 200x400.
 +@example
 +cellauto=f=pattern:s=200x400
  @end example
  
 -@subsection erode
 +@item
 +Generate a random initial row with a width of 200 cells, with a fill
 +ratio of 2/3:
 +@example
 +cellauto=ratio=2/3:s=200x200
 +@end example
  
 -Erode an image by using a specific structuring element.
 -This filter corresponds to the libopencv function @code{cvErode}.
 +@item
 +Create a pattern generated by rule 18 starting by a single alive cell
 +centered on an initial row with width 100:
 +@example
 +cellauto=p=@@:s=100x400:full=0:rule=18
 +@end example
  
 -The filter accepts the parameters: @var{struct_el}:@var{nb_iterations},
 -with the same syntax and semantics as the @ref{dilate} filter.
 +@item
 +Specify a more elaborated initial pattern:
 +@example
 +cellauto=p='@@@@ @@ @@@@':s=100x400:full=0:rule=18
 +@end example
  
 -@subsection smooth
 +@end itemize
  
 -Smooth the input video.
 +@section mandelbrot
  
 -The filter takes the following parameters:
 -@var{type}|@var{param1}|@var{param2}|@var{param3}|@var{param4}.
 +Generate a Mandelbrot set fractal, and progressively zoom towards the
 +point specified with @var{start_x} and @var{start_y}.
  
 -@var{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".
 +This source accepts the following options:
  
 -@var{param1}, @var{param2}, @var{param3}, and @var{param4} are
 -parameters whose meanings depend on smooth type. @var{param1} and
 -@var{param2} accept integer positive values or 0, @var{param3} and
 -@var{param4} accept float values.
 +@table @option
  
 -The default value for @var{param1} is 3, the default value for the
 -other parameters is 0.
 +@item end_pts
 +Set the terminal pts value. Default value is 400.
  
 -These parameters correspond to the parameters assigned to the
 -libopencv function @code{cvSmooth}.
 +@item end_scale
 +Set the terminal scale value.
 +Must be a floating point value. Default value is 0.3.
  
 -@anchor{overlay}
 -@section overlay
 +@item inner
 +Set the inner coloring mode, that is the algorithm used to draw the
 +Mandelbrot fractal internal region.
  
 -Overlay one video on top of another.
 +It shall assume one of the following values:
 +@table @option
 +@item black
 +Set black mode.
 +@item convergence
 +Show time until convergence.
 +@item mincol
 +Set color based on point closest to the origin of the iterations.
 +@item period
 +Set period mode.
 +@end table
  
 -It takes two inputs and one output, the first input is the "main"
 -video on which the second input is overlayed.
 +Default value is @var{mincol}.
  
 -This filter accepts the following parameters:
 +@item bailout
 +Set the bailout value. Default value is 10.0.
  
 +@item maxiter
 +Set the maximum of iterations performed by the rendering
 +algorithm. Default value is 7189.
 +
 +@item outer
 +Set outer coloring mode.
 +It shall assume one of following values:
  @table @option
 +@item iteration_count
 +Set iteration cound mode.
 +@item normalized_iteration_count
 +set normalized iteration count mode.
 +@end table
 +Default value is @var{normalized_iteration_count}.
  
 -@item x
 -The horizontal position of the left edge of the overlaid video on the main video.
 +@item rate, r
 +Set frame rate, expressed as number of frames per second. Default
 +value is "25".
  
 -@item y
 -The vertical position of the top edge of the overlaid video on the main video.
 +@item size, s
 +Set frame size. Default value is "640x480".
 +
 +@item start_scale
 +Set the initial scale value. Default value is 3.0.
 +
 +@item start_x
 +Set the initial x position. Must be a floating point value between
 +-100 and 100. Default value is -0.743643887037158704752191506114774.
  
 +@item start_y
 +Set the initial y position. Must be a floating point value between
 +-100 and 100. Default value is -0.131825904205311970493132056385139.
  @end table
  
 -The parameters are expressions containing the following parameters:
 +@section mptestsrc
  
 -@table @option
 -@item main_w, main_h
 -main input width and height
 +Generate various test patterns, as generated by the MPlayer test filter.
  
 -@item W, H
 -same as @var{main_w} and @var{main_h}
 +The size of the generated video is fixed, and is 256x256.
 +This source is useful in particular for testing encoding features.
  
 -@item overlay_w, overlay_h
 -overlay input width and height
 +This source accepts the following options:
  
 -@item w, h
 -same as @var{overlay_w} and @var{overlay_h}
 -@end table
 +@table @option
  
 -Be aware that frames are taken from each input video in timestamp
 -order, hence, if their initial timestamps differ, it is a a good idea
 -to pass the two inputs through a @var{setpts=PTS-STARTPTS} filter to
 -have them begin in the same zero timestamp, as it does the example for
 -the @var{movie} filter.
 +@item 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
 +@var{frame_rate_num}/@var{frame_rate_den}, an integer number, a float
 +number or a valid video frame rate abbreviation. The default value is
 +"25".
  
 -Follow some examples:
 +@item duration, d
 +Set the video duration of the sourced video. The accepted syntax is:
  @example
 -# draw the overlay at 10 pixels from the bottom right
 -# corner of the main video.
 -overlay=x=main_w-overlay_w-10:y=main_h-overlay_h-10
 +[-]HH:MM:SS[.m...]
 +[-]S+[.m...]
 +@end example
 +See also the function @code{av_parse_time()}.
 +
 +If not specified, or the expressed duration is negative, the video is
 +supposed to be generated forever.
  
 -# insert a transparent PNG logo in the bottom left corner of the input
 -avconv -i input -i logo -filter_complex 'overlay=x=10:y=main_h-overlay_h-10' output
 +@item test, t
 +
 +Set the number or the name of the test to perform. Supported tests are:
 +@table @option
 +@item dc_luma
 +@item dc_chroma
 +@item freq_luma
 +@item freq_chroma
 +@item amp_luma
 +@item amp_chroma
 +@item cbp
 +@item mv
 +@item ring1
 +@item ring2
 +@item all
 +@end table
  
 -# insert 2 different transparent PNG logos (second logo on bottom
 -# right corner):
 -avconv -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
 +Default value is "all", which will cycle through the list of all tests.
 +@end table
  
 -# add a transparent color layer on top of the main video,
 -# WxH specifies the size of the main input to the overlay filter
 -color=red@.3:WxH [over]; [in][over] overlay [out]
 +For example the following:
 +@example
 +testsrc=t=dc_luma
  @end example
  
 -You can chain together more overlays but the efficiency of such
 -approach is yet to be tested.
 +will generate a "dc_luma" test pattern.
  
 -@section pad
 +@section frei0r_src
  
 -Add paddings to the input image, and places the original input at the
 -given coordinates @var{x}, @var{y}.
 +Provide a frei0r source.
  
 -This filter accepts the following parameters:
 +To enable compilation of this filter you need to install the frei0r
 +header and configure FFmpeg with @code{--enable-frei0r}.
 +
 +This source accepts the following options:
  
  @table @option
 -@item width, height
  
 -Specify the size of the output image with the paddings added. If the
 -value for @var{width} or @var{height} is 0, the corresponding input size
 -is used for the output.
 +@item size
 +The size of the video to generate, may be a string of the form
 +@var{width}x@var{height} or a frame size abbreviation.
  
 -The @var{width} expression can reference the value set by the
 -@var{height} expression, and vice versa.
 +@item framerate
 +Framerate of the generated video, may be a string of the form
 +@var{num}/@var{den} or a frame rate abbreviation.
  
 -The default value of @var{width} and @var{height} is 0.
 +@item filter_name
 +The name to the frei0r source to load. For more information regarding frei0r and
 +how to set the parameters read the section @ref{frei0r} in the description of
 +the video filters.
  
 -@item x, y
 +@item filter_params
 +A '|'-separated list of parameters to pass to the frei0r source.
  
 -Specify the offsets where to place the input image in the padded area
 -with respect to the top/left border of the output image.
 +@end table
  
 -The @var{x} expression can reference the value set by the @var{y}
 -expression, and vice versa.
 +For example, to generate a frei0r partik0l source with size 200x200
 +and frame rate 10 which is overlayed on the overlay filter main input:
 +@example
 +frei0r_src=size=200x200:framerate=10:filter_name=partik0l:filter_params=1234 [overlay]; [in][overlay] overlay
 +@end example
  
 -The default value of @var{x} and @var{y} is 0.
 +@section life
  
 -@item color
 +Generate a life pattern.
  
 -Specify the color of the padded area, it can be the name of a color
 -(case insensitive match) or a 0xRRGGBB[AA] sequence.
 +This source is based on a generalization of John Conway's life game.
  
 -The default value of @var{color} is "black".
 +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.
  
 -@end table
 +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 @option{rule} option allows to specify
 +the rule to adopt.
  
 -The parameters @var{width}, @var{height}, @var{x}, and @var{y} are
 -expressions containing the following constants:
 +This source accepts the following options:
  
  @table @option
 -@item E, PI, PHI
 -the corresponding mathematical approximated values for e
 -(euler number), pi (greek PI), phi (golden ratio)
 +@item 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.
  
 -@item in_w, in_h
 -the input video width and height
 +If this option is not specified, the initial grid is generated
 +randomly.
  
 -@item iw, ih
 -same as @var{in_w} and @var{in_h}
 +@item rate, r
 +Set the video rate, that is the number of frames generated per second.
 +Default is 25.
 +
 +@item 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.
 +
 +@item 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.
 +
 +@item rule
 +Set the life rule.
 +
 +A rule can be specified with a code of the kind "S@var{NS}/B@var{NB}",
 +where @var{NS} and @var{NB} are sequences of numbers in the range 0-8,
 +@var{NS} specifies the number of alive neighbor cells which make a
 +live cell stay alive, and @var{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 = @code{(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.
  
 -@item out_w, out_h
 -the output width and height, that is the size of the padded area as
 -specified by the @var{width} and @var{height} expressions
 +@item size, s
 +Set the size of the output video.
  
 -@item ow, oh
 -same as @var{out_w} and @var{out_h}
 +If @option{filename} is specified, the size is set by default to the
 +same size of the input file. If @option{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.
  
 -@item x, y
 -x and y offsets as specified by the @var{x} and @var{y}
 -expressions, or NAN if not yet specified
 +If a filename is not specified, the size value defaults to "320x240"
 +(used for a randomly generated initial grid).
  
 -@item a
 -input display aspect ratio, same as @var{iw} / @var{ih}
 +@item stitch
 +If set to 1, stitch the left and right grid edges together, and the
 +top and bottom edges also. Defaults to 1.
  
 -@item hsub, vsub
 -horizontal and vertical chroma subsample values. For example for the
 -pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.
 +@item mold
 +Set cell mold speed. If set, a dead cell will go from @option{death_color} to
 +@option{mold_color} with a step of @option{mold}. @option{mold} can have a
 +value from 0 to 255.
 +
 +@item life_color
 +Set the color of living (or new born) cells.
 +
 +@item death_color
 +Set the color of dead cells. If @option{mold} is set, this is the first color
 +used to represent a dead cell.
 +
 +@item mold_color
 +Set mold color, for definitely dead and moldy cells.
  @end table
  
 -Some examples follow:
 +@subsection Examples
  
 +@itemize
 +@item
 +Read a grid from @file{pattern}, and center it on a grid of size
 +300x300 pixels:
  @example
 -# 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=width=640:height=480:x=0:y=40:color=violet
 +life=f=pattern:s=300x300
 +@end example
  
 -# pad the input to get an output with dimensions increased bt 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"
 +@item
 +Generate a random grid of size 200x200, with a fill ratio of 2/3:
 +@example
 +life=ratio=2/3:s=200x200
 +@end example
  
 -# 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"
 +@item
 +Specify a custom rule for evolving a randomly generated grid:
 +@example
 +life=rule=S14/B34
 +@end example
  
 -# pad the input to get a final w/h ratio of 16:9
 -pad="ih*16/9:ih:(ow-iw)/2:(oh-ih)/2"
 +@item
 +Full example with slow death effect (mold) using @command{ffplay}:
 +@example
 +ffplay -f lavfi life=s=300x200:mold=10:r=60:ratio=0.1:death_color=#C83232:life_color=#00ff00,scale=1200:800:flags=16
 +@end example
 +@end itemize
  
 -# 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"
 +@section color, nullsrc, rgbtestsrc, smptebars, testsrc
 +
 +The @code{color} source provides an uniformly colored input.
 +
 +The @code{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 @code{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 @code{smptebars} source generates a color bars pattern, based on
 +the SMPTE Engineering Guideline EG 1-1990.
 +
 +The @code{testsrc} source generates a test video pattern, showing a
 +color pattern, a scrolling gradient and a timestamp. This is mainly
 +intended for testing purposes.
 +
 +These sources accept an optional sequence of @var{key}=@var{value} pairs,
 +separated by ":". The description of the accepted options follows.
 +
 +@table @option
 +
 +@item color, c
 +Specify the color of the source, only used in the @code{color}
 +source. It can be the name of a color (case insensitive match) or a
 +0xRRGGBB[AA] sequence, possibly followed by an alpha specifier. The
 +default value is "black".
 +
 +@item size, s
 +Specify the size of the sourced video, it may be a string of the form
 +@var{width}x@var{height}, or the name of a size abbreviation. The
 +default value is "320x240".
 +
 +@item 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
 +@var{frame_rate_num}/@var{frame_rate_den}, an integer number, a float
 +number or a valid video frame rate abbreviation. The default value is
 +"25".
 +
 +@item sar
 +Set the sample aspect ratio of the sourced video.
 +
 +@item duration, d
 +Set the video duration of the sourced video. The accepted syntax is:
 +@example
 +[-]HH[:MM[:SS[.m...]]]
 +[-]S+[.m...]
  @end example
 +See also the function @code{av_parse_time()}.
  
 -@section pixdesctest
 +If not specified, or the expressed duration is negative, the video is
 +supposed to be generated forever.
  
 -Pixel format descriptor test filter, mainly useful for internal
 -testing. The output video should be equal to the input video.
 +@item decimals, n
 +Set the number of decimals to show in the timestamp, only used in the
 +@code{testsrc} source.
  
 -For example:
 +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.
 +@end table
 +
 +For example the following:
  @example
 -format=monow, pixdesctest
 +testsrc=duration=5.3:size=qcif:rate=10
  @end example
  
 -can be used to test the monowhite pixel format descriptor definition.
 +will generate a video with a duration of 5.3 seconds, with size
 +176x144 and a frame rate of 10 frames per second.
  
 -@section scale
 +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.
 +@example
 +color=c=red@@0.2:s=qcif:r=10
 +@end example
  
 -Scale the input video and/or convert the image format.
 +If the input content is to be ignored, @code{nullsrc} can be used. The
 +following command generates noise in the luminance plane by employing
 +the @code{geq} filter:
 +@example
 +nullsrc=s=256x256, geq=random(1)*255:128:128
 +@end example
  
 -This filter accepts the following options:
 +@c man end VIDEO SOURCES
  
 -@table @option
 +@chapter Video Sinks
 +@c man begin VIDEO SINKS
  
 -@item w
 -Output video width.
 +Below is a description of the currently available video sinks.
  
 -@item h
 -Output video height.
 +@section buffersink
  
 -@end table
 +Buffer video frames, and make them available to the end of the filter
 +graph.
  
 -The parameters @var{w} and @var{h} are expressions containing
 -the following constants:
 +This sink is mainly intended for a programmatic use, in particular
 +through the interface defined in @file{libavfilter/buffersink.h}.
  
 -@table @option
 -@item E, PI, PHI
 -the corresponding mathematical approximated values for e
 -(euler number), pi (greek PI), phi (golden ratio)
 +It does not require a string parameter in input, but you need to
 +specify a pointer to a list of supported pixel formats terminated by
 +-1 in the opaque parameter provided to @code{avfilter_init_filter}
 +when initializing this sink.
  
 -@item in_w, in_h
 -the input width and height
 +@section nullsink
  
 -@item iw, ih
 -same as @var{in_w} and @var{in_h}
 +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.
  
 -@item out_w, out_h
 -the output (cropped) width and height
 +@c man end VIDEO SINKS
  
 -@item ow, oh
 -same as @var{out_w} and @var{out_h}
 +@chapter Multimedia Filters
 +@c man begin MULTIMEDIA FILTERS
  
 -@item dar, a
 -input display aspect ratio, same as @var{iw} / @var{ih}
 +Below is a description of the currently available multimedia filters.
  
 -@item sar
 -input sample aspect ratio
 +@section aperms, perms
  
 -@item hsub, vsub
 -horizontal and vertical chroma subsample values. For example for the
 -pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.
 +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:
 +
 +@table @option
 +@item mode
 +Select the permissions mode.
 +
 +It accepts the following values:
 +@table @samp
 +@item none
 +Do nothing. This is the default.
 +@item ro
 +Set all the output frames read-only.
 +@item rw
 +Set all the output frames directly writable.
 +@item toggle
 +Make the frame read-only if writable, and writable if read-only.
 +@item random
 +Set each output frame read-only or writable randomly.
  @end table
  
 -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.
 +@item seed
 +Set the seed for the @var{random} mode, must be an integer included between
 +@code{0} and @code{UINT32_MAX}. If not specified, or if explicitly set to
 +@code{-1}, the filter will try to use a good random seed on a best effort
 +basis.
 +@end table
  
 -If the value for @var{w} or @var{h} is 0, the respective input
 -size is used for the output.
 +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 @ref{format} or @ref{aformat} filter before the
 +perms/aperms filter can avoid this problem.
  
 -If the value for @var{w} or @var{h} is -1, the scale filter will use, for the
 -respective output size, a value that maintains the aspect ratio of the input
 -image.
 +@section aphaser
 +Add a phasing effect to the input audio.
  
 -The default value of @var{w} and @var{h} is 0.
 +A phaser filter creates series of peaks and troughs in the frequency spectrum.
 +The position of the peaks and troughs are modulated so that they vary over time, creating a sweeping effect.
  
 -Some examples follow:
 -@example
 -# scale the input video to a size of 200x100.
 -scale=w=200:h=100
 +The filter accepts parameters as a list of @var{key}=@var{value}
 +pairs, separated by ":".
  
 -# 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
 +A description of the accepted parameters follows.
  
 -# scale the input to half size
 -scale=w=iw/2:h=ih/2
 +@table @option
 +@item in_gain
 +Set input gain. Default is 0.4.
  
 -# increase the width, and set the height to the same size
 -scale=3/2*iw:ow
 +@item out_gain
 +Set output gain. Default is 0.74
  
 -# seek for Greek harmony
 -scale=iw:1/PHI*iw
 -scale=ih*PHI:ih
 +@item delay
 +Set delay in milliseconds. Default is 3.0.
  
 -# increase the height, and set the width to 3/2 of the height
 -scale=w=3/2*oh:h=3/5*ih
 +@item decay
 +Set decay. Default is 0.4.
  
 -# increase the size, but make the size a multiple of the chroma
 -scale="trunc(3/2*iw/hsub)*hsub:trunc(3/2*ih/vsub)*vsub"
 +@item speed
 +Set modulation speed in Hz. Default is 0.5.
  
 -# increase the width to a maximum of 500 pixels, keep the same input aspect ratio
 -scale=w='min(500\, iw*3/2):h=-1'
 -@end example
 +@item type
 +Set modulation type. Default is triangular.
 +
 +It accepts the following values:
 +@table @samp
 +@item triangular, t
 +@item sinusoidal, s
 +@end table
 +@end table
  
 -@section select
 +@section aselect, select
  Select frames to pass in output.
  
  This filter accepts the following options:
@@@ -655,81 -479,8 +655,82 @@@ int avfilter_init_filter(AVFilterContex
      AVDictionary *options = NULL;
      AVDictionaryEntry *e;
      int ret=0;
 +    int anton_options =
 +        !strcmp(filter->filter->name,  "aformat") ||
 +        !strcmp(filter->filter->name,  "ass")     ||
 +        !strcmp(filter->filter->name,  "blackframe") ||
 +        !strcmp(filter->filter->name,  "boxblur"   ) ||
 +        !strcmp(filter->filter->name,  "cellauto") ||
 +        !strcmp(filter->filter->name,  "colormatrix") ||
 +        !strcmp(filter->filter->name,  "crop"      ) ||
 +        !strcmp(filter->filter->name,  "cropdetect") ||
 +        !strcmp(filter->filter->name,  "curves"    ) ||
 +        !strcmp(filter->filter->name,  "decimate"  ) ||
 +        !strcmp(filter->filter->name,  "delogo"    ) ||
 +        !strcmp(filter->filter->name,  "drawbox"   ) ||
 +        !strcmp(filter->filter->name,  "drawtext"  ) ||
 +        !strcmp(filter->filter->name,  "ebur128"   ) ||
 +        !strcmp(filter->filter->name,  "edgedetect") ||
 +        !strcmp(filter->filter->name,  "fade"      ) ||
 +        !strcmp(filter->filter->name,  "field"     ) ||
 +        !strcmp(filter->filter->name,  "fieldorder") ||
 +        !strcmp(filter->filter->name,  "fps"       ) ||
 +        !strcmp(filter->filter->name,  "frei0r"    ) ||
 +        !strcmp(filter->filter->name,  "frei0r_src") ||
 +        !strcmp(filter->filter->name,  "geq"       ) ||
 +        !strcmp(filter->filter->name, "gradfun"    ) ||
 +        !strcmp(filter->filter->name, "histeq"     ) ||
 +        !strcmp(filter->filter->name, "histogram"  ) ||
 +        !strcmp(filter->filter->name, "hqdn3d"     ) ||
 +        !strcmp(filter->filter->name, "idet"       ) ||
 +        !strcmp(filter->filter->name,  "il"        ) ||
 +        !strcmp(filter->filter->name,  "kerndeint" ) ||
 +        !strcmp(filter->filter->name, "ocv"        ) ||
 +        !strcmp(filter->filter->name, "life"       ) ||
 +        !strcmp(filter->filter->name, "lut"        ) ||
 +        !strcmp(filter->filter->name, "lutyuv"     ) ||
 +        !strcmp(filter->filter->name, "lutrgb"     ) ||
 +        !strcmp(filter->filter->name, "mandelbrot" ) ||
 +        !strcmp(filter->filter->name, "mptestsrc"  ) ||
 +        !strcmp(filter->filter->name, "negate"     ) ||
 +        !strcmp(filter->filter->name, "noise"      ) ||
 +        !strcmp(filter->filter->name, "overlay"    ) ||
 +        !strcmp(filter->filter->name, "pad"        ) ||
 +        !strcmp(filter->filter->name,   "format") ||
 +        !strcmp(filter->filter->name, "noformat") ||
 +        !strcmp(filter->filter->name, "perms")  ||
 +        !strcmp(filter->filter->name, "pp"   )  ||
 +        !strcmp(filter->filter->name, "aperms") ||
 +        !strcmp(filter->filter->name, "resample") ||
 +        !strcmp(filter->filter->name, "setpts"       ) ||
 +        !strcmp(filter->filter->name, "settb"        ) ||
 +        !strcmp(filter->filter->name, "showspectrum") ||
 +        !strcmp(filter->filter->name, "silencedetect") ||
 +        !strcmp(filter->filter->name, "smartblur") ||
 +        !strcmp(filter->filter->name, "stereo3d" ) ||
 +        !strcmp(filter->filter->name, "subtitles") ||
 +        !strcmp(filter->filter->name, "thumbnail") ||
 +        !strcmp(filter->filter->name, "transpose") ||
 +        !strcmp(filter->filter->name, "unsharp"  ) ||
 +//         !strcmp(filter->filter->name, "scale"      ) ||
 +        !strcmp(filter->filter->name, "select") ||
++        !strcmp(filter->filter->name, "yadif"    ) ||
 +        0
 +        ;
 +
 +    if (filter->filter->shorthand) {
 +        av_assert0(filter->priv);
 +        av_assert0(filter->filter->priv_class);
 +        *(const AVClass **)filter->priv = filter->filter->priv_class;
 +        av_opt_set_defaults(filter->priv);
 +        ret = av_opt_set_from_string(filter->priv, args,
 +                                     filter->filter->shorthand, "=", ":");
 +        if (ret < 0)
 +            return ret;
 +        args = NULL;
 +    }
  
 -    if (args && *args && filter->filter->priv_class) {
 +    if (anton_options && args && *args && filter->filter->priv_class) {
  #if FF_API_OLD_FILTER_OPTS
          if (!strcmp(filter->filter->name, "scale") &&
              strchr(args, ':') < strchr(args, '=')) {
@@@ -344,32 -363,34 +344,6 @@@ static int request_frame(AVFilterLink *
      return 0;
  }
  
- #define OFFSET(x) offsetof(YADIFContext, x)
- #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
- #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
 -static int poll_frame(AVFilterLink *link)
 -{
 -    YADIFContext *yadif = link->src->priv;
 -    int ret, val;
--
- static const AVOption yadif_options[] = {
-     { "mode",   "specify the interlacing mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FRAME}, 0, 3, FLAGS, "mode"},
-     CONST("send_frame",           "send one frame for each frame",                                     YADIF_MODE_SEND_FRAME,           "mode"),
-     CONST("send_field",           "send one frame for each field",                                     YADIF_MODE_SEND_FIELD,           "mode"),
-     CONST("send_frame_nospatial", "send one frame for each frame, but skip spatial interlacing check", YADIF_MODE_SEND_FRAME_NOSPATIAL, "mode"),
-     CONST("send_field_nospatial", "send one frame for each field, but skip spatial interlacing check", YADIF_MODE_SEND_FIELD_NOSPATIAL, "mode"),
 -    if (yadif->frame_pending)
 -        return 1;
--
-     { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1, FLAGS, "parity" },
-     CONST("tff",  "assume top field first",    YADIF_PARITY_TFF,  "parity"),
-     CONST("bff",  "assume bottom field first", YADIF_PARITY_BFF,  "parity"),
-     CONST("auto", "auto detect parity",        YADIF_PARITY_AUTO, "parity"),
 -    val = ff_poll_frame(link->src->inputs[0]);
 -    if (val <= 0)
 -        return val;
--
-     { "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
-     CONST("all",        "deinterlace all frames",                       YADIF_DEINT_ALL,         "deint"),
-     CONST("interlaced", "only deinterlace frames marked as interlaced", YADIF_DEINT_INTERLACED,  "deint"),
 -    //FIXME change API to not requre this red tape
 -    if (val == 1 && !yadif->next) {
 -        if ((ret = ff_request_frame(link->src->inputs[0])) < 0)
 -            return ret;
 -        val = ff_poll_frame(link->src->inputs[0]);
 -        if (val <= 0)
 -            return val;
 -    }
 -    assert(yadif->next || !val);
--
-     {NULL},
- };
 -    if (yadif->auto_enable && yadif->next && !yadif->next->interlaced_frame)
 -        return val;
--
- AVFILTER_DEFINE_CLASS(yadif);
 -    return val * ((yadif->mode&1)+1);
 -}
--
  static av_cold void uninit(AVFilterContext *ctx)
  {
      YADIFContext *yadif = ctx->priv;
@@@ -420,19 -430,8 +394,9 @@@ static int query_formats(AVFilterContex
      return 0;
  }
  
- static av_cold int init(AVFilterContext *ctx, const char *args)
- {
-     YADIFContext *yadif = ctx->priv;
-     av_log(ctx, AV_LOG_VERBOSE, "mode:%d parity:%d deint:%d\n",
-            yadif->mode, yadif->parity, yadif->deint);
-     return 0;
- }
  static int config_props(AVFilterLink *link)
  {
 +    AVFilterContext *ctx = link->src;
      YADIFContext *s = link->src->priv;
  
      link->time_base.num = link->src->inputs[0]->time_base.num;
      return 0;
  }
  
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
 -static const AVOption options[] = {
 -    { "mode",   NULL, OFFSET(mode),        AV_OPT_TYPE_INT, { .i64 = 0  },  0, 3, FLAGS },
 -    { "parity", NULL, OFFSET(parity),      AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, FLAGS, "parity" },
 -        { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, .unit = "parity" },
 -        { "tff",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0  }, .unit = "parity" },
 -        { "bff",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1  }, .unit = "parity" },
 -    { "auto",   NULL, OFFSET(auto_enable), AV_OPT_TYPE_INT, { .i64 = 0  },  0, 1, FLAGS },
 -    { NULL },
 -};
++
+ #define OFFSET(x) offsetof(YADIFContext, x)
 -static const AVClass yadif_class = {
 -    .class_name = "yadif",
 -    .item_name  = av_default_item_name,
 -    .option     = options,
 -    .version    = LIBAVUTIL_VERSION_INT,
++#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
++
++#define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
++
++static const AVOption yadif_options[] = {
++    { "mode",   "specify the interlacing mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FRAME}, 0, 3, FLAGS, "mode"},
++    CONST("send_frame",           "send one frame for each frame",                                     YADIF_MODE_SEND_FRAME,           "mode"),
++    CONST("send_field",           "send one frame for each field",                                     YADIF_MODE_SEND_FIELD,           "mode"),
++    CONST("send_frame_nospatial", "send one frame for each frame, but skip spatial interlacing check", YADIF_MODE_SEND_FRAME_NOSPATIAL, "mode"),
++    CONST("send_field_nospatial", "send one frame for each field, but skip spatial interlacing check", YADIF_MODE_SEND_FIELD_NOSPATIAL, "mode"),
++    { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1, FLAGS, "parity" },
++    CONST("tff",  "assume top field first",    YADIF_PARITY_TFF,  "parity"),
++    CONST("bff",  "assume bottom field first", YADIF_PARITY_BFF,  "parity"),
++    CONST("auto", "auto detect parity",        YADIF_PARITY_AUTO, "parity"),
++
++    { "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
++    CONST("all",        "deinterlace all frames",                       YADIF_DEINT_ALL,         "deint"),
++    CONST("interlaced", "only deinterlace frames marked as interlaced", YADIF_DEINT_INTERLACED,  "deint"),
++
++    {NULL},
+ };
++AVFILTER_DEFINE_CLASS(yadif);
++
  static const AVFilterPad avfilter_vf_yadif_inputs[] = {
      {
          .name             = "default",
@@@ -482,20 -494,16 +473,15 @@@ static const AVFilterPad avfilter_vf_ya
      { NULL }
  };
  
- static const char *const shorthand[] = { "mode", "parity", "deint", NULL };
  AVFilter avfilter_vf_yadif = {
      .name          = "yadif",
 -    .description   = NULL_IF_CONFIG_SMALL("Deinterlace the input image"),
 +    .description   = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
  
      .priv_size     = sizeof(YADIFContext),
-     .init          = init,
+     .priv_class    = &yadif_class,
      .uninit        = uninit,
      .query_formats = query_formats,
  
      .inputs    = avfilter_vf_yadif_inputs,
 -
      .outputs   = avfilter_vf_yadif_outputs,
-     .priv_class = &yadif_class,
-     .shorthand = shorthand,
  };