Merge commit 'b83e9efc53e5491716625aa31c69006b1119b280'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 22:50:53 +0000 (00:50 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 23:02:07 +0000 (01:02 +0200)
* commit 'b83e9efc53e5491716625aa31c69006b1119b280':
  vf_unsharp: switch to an AVOptions-based system.

Conflicts:
doc/filters.texi
libavfilter/vf_unsharp.c

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

@@@ -5436,483 -1088,300 +5436,479 @@@ the area will be used
  
  @end table
  
 -Some examples follow:
 +Alternatively, the options can be specified as a flat string:
 +
 +@var{layout}[:@var{nb_frames}[:@var{margin}[:@var{padding}]]]
 +
 +For example, produce 8x8 PNG tiles of all keyframes (@option{-skip_frame
 +nokey}) in a movie:
  @example
 -# convert the input video to the format "yuv420p"
 -format=pix_fmts=yuv420p
 +ffmpeg -skip_frame nokey -i file.avi -vf 'scale=128:72,tile=8x8' -an -vsync 0 keyframes%03d.png
 +@end example
 +The @option{-vsync 0} is necessary to prevent @command{ffmpeg} from
 +duplicating each output frame to accomodate the originally detected frame
 +rate.
  
 -# convert the input video to any of the formats in the list
 -format=pix_fmts=yuv420p|yuv444p|yuv410p
 +Another example to display @code{5} pictures in an area of @code{3x2} frames,
 +with @code{7} pixels between them, and @code{2} pixels of initial margin, using
 +mixed flat and named options:
 +@example
 +tile=3x2:nb_frames=5:padding=7:margin=2
  @end example
  
 -@section fps
 +@section tinterlace
  
 -Convert the video to specified constant framerate by duplicating or dropping
 -frames as necessary.
 +Perform various types of temporal field interlacing.
 +
 +Frames are counted starting from 1, so the first input frame is
 +considered odd.
 +
 +This filter accepts options in the form of @var{key}=@var{value} pairs
 +separated by ":".
 +Alternatively, the @var{mode} option can be specified as a value alone,
 +optionally followed by a ":" and further ":" separated @var{key}=@var{value}
 +pairs.
 +
 +A description of the accepted options follows.
  
 -This filter accepts the following named parameters:
  @table @option
  
 -@item fps
 -Desired output framerate.
 +@item 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:
 +
 +@table @samp
 +@item merge, 0
 +Move odd frames into the upper field, even into the lower field,
 +generating a double height frame at half frame rate.
 +
 +@item drop_odd, 1
 +Only output even frames, odd frames are dropped, generating a frame with
 +unchanged height at half frame rate.
 +
 +@item drop_even, 2
 +Only output odd frames, even frames are dropped, generating a frame with
 +unchanged height at half frame rate.
 +
 +@item 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.
 +
 +@item 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.
 +
 +@item 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.
 +
 +@item 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.
  @end table
  
 -@anchor{frei0r}
 -@section frei0r
 +Numeric values are deprecated but are accepted for backward
 +compatibility reasons.
  
 -Apply a frei0r effect to the input video.
 +Default mode is @code{merge}.
  
 -To enable compilation of this filter you need to install the frei0r
 -header and configure Libav with --enable-frei0r.
 +@item flags
 +Specify flags influencing the filter process.
  
 -This filter accepts the following options:
 +Available value for @var{flags} is:
  
  @table @option
 +@item 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.
  
 -@item filter_name
 -The name to the frei0r effect to load. If the environment variable
 -@env{FREI0R_PATH} is defined, the frei0r effect is searched in each one of the
 -directories specified by the colon separated list in @env{FREIOR_PATH},
 -otherwise in the standard frei0r paths, which are in this order:
 -@file{HOME/.frei0r-1/lib/}, @file{/usr/local/lib/frei0r-1/},
 -@file{/usr/lib/frei0r-1/}.
 +Vertical low-pass filtering can only be enabled for @option{mode}
 +@var{interleave_top} and @var{interleave_bottom}.
  
 -@item filter_params
 -A '|'-separated list of parameters to pass to the frei0r effect.
 +@end table
 +@end table
 +
 +@section transpose
 +
 +Transpose rows with columns in the input video and optionally flip it.
  
 -@end table
 +This filter accepts the following options:
  
 -A frei0r effect parameter can be a boolean (whose values are specified
 -with "y" and "n"), a double, a color (specified by the syntax
 -@var{R}/@var{G}/@var{B}, @var{R}, @var{G}, and @var{B} being float
 -numbers from 0.0 to 1.0) or by an @code{av_parse_color()} color
 -description), a position (specified by the syntax @var{X}/@var{Y},
 -@var{X} and @var{Y} being float numbers) and a string.
 +@table @option
  
 -The number and kind of parameters depend on the loaded effect. If an
 -effect parameter is not specified the default value is set.
 +@item dir
 +The direction of the transpose.
  
 -Some examples follow:
 +@table @samp
 +@item 0, 4, cclock_flip
 +Rotate by 90 degrees counterclockwise and vertically flip (default), that is:
  @example
 -# apply the distort0r effect, set the first two double parameters
 -frei0r=filter_name=distort0r:filter_params=0.5|0.01
 +L.R     L.l
 +. . ->  . .
 +l.r     R.r
 +@end example
  
 -# apply the colordistance effect, takes a color as first parameter
 -frei0r=colordistance:0.2/0.3/0.4
 -frei0r=colordistance:violet
 -frei0r=colordistance:0x112233
 +@item 1, 5, clock
 +Rotate by 90 degrees clockwise, that is:
 +@example
 +L.R     l.L
 +. . ->  . .
 +l.r     r.R
 +@end example
  
 -# apply the perspective effect, specify the top left and top right
 -# image positions
 -frei0r=perspective:0.2/0.2|0.8/0.2
 +@item 2, 6, cclock
 +Rotate by 90 degrees counterclockwise, that is:
 +@example
 +L.R     R.r
 +. . ->  . .
 +l.r     L.l
  @end example
  
 -For more information see:
 -@url{http://piksel.org/frei0r}
 +@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 gradfun
 +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.
  
 -Fix the banding artifacts that are sometimes introduced into nearly flat
 -regions by truncation to 8bit colordepth.
 -Interpolate the gradients that should go where the bands are, and
 -dither them.
 +@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
  
 -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.
 +Default value is @code{none}.
 +@end table
  
 -This filter accepts the following options:
 +For example to rotate by 90 degrees clockwise and preserve portrait
 +layout:
 +@example
 +transpose=dir=1:passthrough=portrait
 +@end example
  
 -@table @option
 +The command above can also be specified as:
 +@example
 +transpose=1:portrait
 +@end example
  
 -@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.
 +@section unsharp
  
 -@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.
 +Sharpen or blur the input video.
 +
- This 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 the syntax:
- @var{luma_msize_x}:@var{luma_msize_y}:@var{luma_amount}:@var{chroma_msize_x}:@var{chroma_msize_y}:@var{chroma_amount}
- A description of the accepted options follows.
++It accepts the following parameters:
  
 +@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
  
++All parameters are optional and default to the
++equivalent of the string '5:5:1.0:5:5:0.0'.
++
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply strong luma sharpen effect:
  @example
- unsharp=7:7:2.5
 -# default parameters
 -gradfun=strength=1.2:radius=16
++unsharp=luma_msize_x=7:luma_msize_y=7:luma_amount=2.5
 +@end example
  
 -# omitting radius
 -gradfun=1.2
 +@item
 +Apply strong blur of both luma and chroma parameters:
 +@example
 +unsharp=7:7:-2:7:7:-2
  @end example
 +@end itemize
  
 -@section hflip
 +@section vflip
  
 -Flip the input video horizontally.
 +Flip the input video vertically.
  
 -For example to horizontally flip the input video with @command{avconv}:
  @example
 -avconv -i in.avi -vf "hflip" out.avi
 +ffmpeg -i in.avi -vf "vflip" out.avi
  @end example
  
 -@section hqdn3d
 +@section yadif
  
 -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.
 +Deinterlace the input video ("yadif" means "yet another deinterlacing
 +filter").
  
 -It accepts the following optional parameters:
 +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 description of the accepted parameters follows.
  
  @table @option
 -@item luma_spatial
 -a non-negative float number which specifies spatial luma strength,
 -defaults to 4.0
 +@item mode
 +Specify the interlacing mode to adopt. Accept one of the following
 +values:
  
 -@item chroma_spatial
 -a non-negative float number which specifies spatial chroma strength,
 -defaults to 3.0*@var{luma_spatial}/4.0
 +@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 luma_tmp
 -a float number which specifies luma temporal strength, defaults to
 -6.0*@var{luma_spatial}/4.0
 +Default value is @code{send_frame}.
  
 -@item chroma_tmp
 -a float number which specifies chroma temporal strength, defaults to
 -@var{luma_tmp}*@var{chroma_spatial}/@var{luma_spatial}
 -@end table
 +@item parity
 +Specify the picture field parity assumed for the input interlaced
 +video. Accept one of the following values:
  
 -@section lut, lutrgb, lutyuv
 +@table @option
 +@item 0, tff
 +assume top field first
 +@item 1, bff
 +assume bottom field first
 +@item -1, auto
 +enable automatic detection
 +@end table
  
 -Compute a look-up table for binding each pixel component input value
 -to an output value, and apply it to input video.
 +Default value is @code{auto}.
 +If interlacing is unknown or decoder does not export this information,
 +top field first will be assumed.
  
 -@var{lutyuv} applies a lookup table to a YUV input video, @var{lutrgb}
 -to an RGB input video.
 +@item deint
 +Specify which frames to deinterlace. Accept one of the following
 +values:
  
 -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 @var{r} (red component)
 -@item @var{g} (green component)
 -@item @var{b} (blue component)
 -@item @var{a} (alpha component)
 +@item 0, all
 +deinterlace all frames
 +@item 1, interlaced
 +only deinterlace frames marked as interlaced
 +@end table
  
 -@item @var{y} (Y/luminance component)
 -@item @var{u} (U/Cb component)
 -@item @var{v} (V/Cr component)
 +Default value is @code{all}.
  @end table
  
 -Each of them specifies the expression to use for computing the lookup table for
 -the corresponding pixel component values.
 +@c man end VIDEO FILTERS
  
 -The exact component associated to each of the @var{c*} options depends on the
 -format in input.
 +@chapter Video Sources
 +@c man begin VIDEO SOURCES
  
 -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.
 +Below is a description of the currently available video sources.
  
 -The expressions can contain the following constants and functions:
 +@section buffer
  
 -@table @option
 -@item E, PI, PHI
 -the corresponding mathematical approximated values for e
 -(euler number), pi (greek PI), PHI (golden ratio)
 +Buffer video frames, and make them available to the filter chain.
  
 -@item w, h
 -the input width and height
 +This source is mainly intended for a programmatic use, in particular
 +through the interface defined in @file{libavfilter/vsrc_buffer.h}.
  
 -@item val
 -input value for the pixel component
 +It accepts a list of options in the form of @var{key}=@var{value} pairs
 +separated by ":". A description of the accepted options follows.
  
 -@item clipval
 -the input value clipped in the @var{minval}-@var{maxval} range
 +@table @option
  
 -@item maxval
 -maximum value for the pixel component
 +@item video_size
 +Specify the size (width and height) of the buffered video frames.
  
 -@item minval
 -minimum value for the pixel component
 +@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.
  
 -@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"
 +@item time_base
 +Specify the timebase assumed by the timestamps of the buffered frames.
  
 -@item clip(val)
 -the computed value in @var{val} clipped in the
 -@var{minval}-@var{maxval} range
 +@item time_base
 +Specify the frame rate expected for the video stream.
  
 -@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 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
  
 -All expressions default to "val".
 +For example:
 +@example
 +buffer=size=320x240:pix_fmt=yuv410p:time_base=1/24:pixel_aspect=1/1
 +@end example
  
 -Some examples follow:
 +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
 -# 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"
 +buffer=size=320x240:pixfmt=6:time_base=1/24:pixel_aspect=1/1
 +@end example
  
 -# the above is the same as
 -lutrgb="r=negval:g=negval:b=negval"
 -lutyuv="y=negval:u=negval:v=negval"
 +Alternatively, the options can be specified as a flat string, but this
 +syntax is deprecated:
  
 -# negate luminance
 -lutyuv=negval
 +@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}]
  
 -# remove chroma components, turns the video into a graytone image
 -lutyuv="u=128:v=128"
 +@section cellauto
  
 -# apply a luma burning effect
 -lutyuv="y=2*val"
 +Create a pattern generated by an elementary cellular automaton.
  
 -# remove green and blue components
 -lutrgb="g=0:b=0"
 +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.
  
 -# set a constant alpha channel value on input
 -format=rgba,lutrgb=a="maxval-minval/2"
 +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.
  
 -# correct luminance gamma by a 0.5 factor
 -lutyuv=y=gammaval(0.5)
 -@end example
 +This source accepts the following options:
  
 -@section negate
 +@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.
  
 -Negate input video.
 +@item pattern, p
 +Read the initial cellular automaton state, i.e. the starting row, from
 +the specified string.
  
 -This filter accepts an integer in input, if non-zero it negates the
 -alpha component (if available). The default value in input is 0.
 +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.
  
 -@section noformat
 +@item rate, r
 +Set the video rate, that is the number of frames generated per second.
 +Default is 25.
  
 -Force libavfilter not to use any of the specified pixel formats for the
 -input to the next filter.
 +@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.
  
 -This filter accepts the following parameters:
 -@table @option
 +This option is ignored when a file or a pattern is specified.
  
 -@item pix_fmts
 -A '|'-separated list of pixel format names, for example
 -"pix_fmts=yuv420p|monow|rgb24".
 +@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.
 +
 +@item rule
 +Set the cellular automaton rule, it is a number ranging from 0 to 255.
 +Default value is 110.
 +
 +@item size, s
 +Set the size of the output video.
 +
 +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.
 +
 +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 a filename or a pattern string is not specified, the size value
 +defaults to "320x518" (used for a randomly generated initial state).
 +
 +@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.
 +
 +@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.
 +
 +@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
  
 -Some examples follow:
 +@subsection Examples
 +
 +@itemize
 +@item
 +Read the initial state from @file{pattern}, and specify an output of
 +size 200x400.
  @example
 -# force libavfilter to use a format different from "yuv420p" for the
 -# input to the vflip filter
 -noformat=pix_fmts=yuv420p,vflip
 +cellauto=f=pattern:s=200x400
 +@end example
  
 -# convert the input video to any of the formats not contained in the list
 -noformat=yuv420p|yuv444p|yuv410p
 +@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
  
 -@section null
 +@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
  
 -Pass the video source unchanged to the output.
 +@item
 +Specify a more elaborated initial pattern:
 +@example
 +cellauto=p='@@@@ @@ @@@@':s=100x400:full=0:rule=18
 +@end example
  
 -@section ocv
 +@end itemize
  
 -Apply video transform using libopencv.
 +@section mandelbrot
  
 -To enable this filter install libopencv library and headers and
 -configure Libav with --enable-libopencv.
 +Generate a Mandelbrot set fractal, and progressively zoom towards the
 +point specified with @var{start_x} and @var{start_y}.
  
 -This filter accepts the following parameters:
 +This source accepts the following options:
  
  @table @option
  
@@@ -655,73 -479,8 +655,74 @@@ 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, "hqdn3d"     ) ||
 +        !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, "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, "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") ||
 +        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, '=')) {
@@@ -170,8 -140,8 +147,9 @@@ static av_cold int init(AVFilterContex
  {
      UnsharpContext *unsharp = ctx->priv;
  
-     set_filter_param(&unsharp->luma,   unsharp->luma_msize_x,   unsharp->luma_msize_y,   unsharp->luma_amount);
-     set_filter_param(&unsharp->chroma, unsharp->chroma_msize_x, unsharp->chroma_msize_y, unsharp->chroma_amount);
++
+     set_filter_param(&unsharp->luma,   unsharp->lmsize_x, unsharp->lmsize_y, unsharp->lamount);
+     set_filter_param(&unsharp->chroma, unsharp->cmsize_x, unsharp->cmsize_y, unsharp->camount);
  
      return 0;
  }
@@@ -269,6 -226,25 +247,28 @@@ static int filter_frame(AVFilterLink *l
      return ff_filter_frame(outlink, out);
  }
  
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
 -static const AVOption options[] = {
+ #define OFFSET(x) offsetof(UnsharpContext, x)
 -static const AVClass unsharp_class = {
 -    .class_name = "unsharp",
 -    .item_name  = av_default_item_name,
 -    .option     = options,
 -    .version    = LIBAVUTIL_VERSION_INT,
 -};
++#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
++#define MIN_SIZE 3
++#define MAX_SIZE 63
++static const AVOption unsharp_options[] = {
+     { "luma_msize_x",   "luma matrix horizontal size",   OFFSET(lmsize_x), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
++    { "lx",             "luma matrix horizontal size",   OFFSET(lmsize_x), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
+     { "luma_msize_y",   "luma matrix vertical size",     OFFSET(lmsize_y), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
++    { "ly",             "luma matrix vertical size",     OFFSET(lmsize_y), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
+     { "luma_amount",    "luma effect strength",          OFFSET(lamount),  AV_OPT_TYPE_FLOAT, { .dbl = 1 },       -2,        5, FLAGS },
++    { "la",             "luma effect strength",          OFFSET(lamount),  AV_OPT_TYPE_FLOAT, { .dbl = 1 },       -2,        5, FLAGS },
+     { "chroma_msize_x", "chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
++    { "cx",             "chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
+     { "chroma_msize_y", "chroma matrix vertical size",   OFFSET(cmsize_y), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
++    { "cy",             "chroma matrix vertical size",   OFFSET(cmsize_y), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
+     { "chroma_amount",  "chroma effect strength",        OFFSET(camount),  AV_OPT_TYPE_FLOAT, { .dbl = 0 },       -2,        5, FLAGS },
++    { "ca",             "chroma effect strength",        OFFSET(camount),  AV_OPT_TYPE_FLOAT, { .dbl = 0 },       -2,        5, FLAGS },
+     { NULL },
+ };
++AVFILTER_DEFINE_CLASS(unsharp);
  static const AVFilterPad avfilter_vf_unsharp_inputs[] = {
      {
          .name         = "default",