Merge commit '0c2466dec719b933d161f5d680a57fde38aa5daa'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 22:32:50 +0000 (00:32 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 22:33:31 +0000 (00:33 +0200)
* commit '0c2466dec719b933d161f5d680a57fde38aa5daa':
  vf_transpose: switch to an AVOptions-based system.

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

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

@@@ -5473,452 -1122,266 +5473,450 @@@ A description of the accepted options f
  
  @table @option
  
 -@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/}.
 +@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.
  
 -@item filter_params
 -A '|'-separated list of parameters to pass to the frei0r effect.
 +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
 +
 +Numeric values are deprecated but are accepted for backward
 +compatibility reasons.
 +
 +Default mode is @code{merge}.
 +
 +@item flags
 +Specify flags influencing the filter process.
 +
 +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.
 +
 +Vertical low-pass filtering can only be enabled for @option{mode}
 +@var{interleave_top} and @var{interleave_bottom}.
  
  @end table
 +@end table
  
 -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.
 +@section transpose
  
 -The number and kind of parameters depend on the loaded effect. If an
 -effect parameter is not specified the default value is set.
 +Transpose rows with columns in the input video and optionally flip it.
 +
- 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 the syntax
- @var{dir}:@var{passthrough}.
++This filter accepts the following options:
 +
 +@table @option
++
 +@item dir
- Specify the transposition direction. Can assume the following values:
++The direction of the transpose.
  
 -Some examples follow:
 +@table @samp
- @item 0, 4
++@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
  
- @item 1, 5
 -# 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
  
- @item 2, 6
 -# 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
  
- @item 3, 7
 -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.
  
 +@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
  
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply strong luma sharpen effect:
  @example
 -# default parameters
 -gradfun=strength=1.2:radius=16
 +unsharp=7:7: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 a list of options in the form of
 +@var{key}=@var{value} pairs separated by ":". A description of the
 +accepted options follows.
  
 -@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 a list of options in the form of
 +@var{key}=@var{value} pairs separated by ":". A description of the
 +accepted options follows.
  
  @table @option
  
@@@ -655,68 -479,8 +655,69 @@@ 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,  "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, "lut"        ) ||
 +        !strcmp(filter->filter->name, "lutyuv"     ) ||
 +        !strcmp(filter->filter->name, "lutrgb"     ) ||
 +        !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, "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, '=')) {
  #include "internal.h"
  #include "video.h"
  
 +typedef enum {
 +    TRANSPOSE_PT_TYPE_NONE,
 +    TRANSPOSE_PT_TYPE_LANDSCAPE,
 +    TRANSPOSE_PT_TYPE_PORTRAIT,
 +} PassthroughType;
 +
+ enum TransposeDir {
+     TRANSPOSE_CCLOCK_FLIP,
+     TRANSPOSE_CLOCK,
+     TRANSPOSE_CCLOCK,
+     TRANSPOSE_CLOCK_FLIP,
+ };
  typedef struct {
      const AVClass *class;
      int hsub, vsub;
      int pixsteps[4];
  
-     /* 0    Rotate by 90 degrees counterclockwise and vflip. */
-     /* 1    Rotate by 90 degrees clockwise.                  */
-     /* 2    Rotate by 90 degrees counterclockwise.           */
-     /* 3    Rotate by 90 degrees clockwise and vflip.        */
-     int dir;
 +    PassthroughType passthrough; ///< landscape passthrough mode enabled
+     enum TransposeDir dir;
  } TransContext;
  
- #define OFFSET(x) offsetof(TransContext, x)
- #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
- static const AVOption transpose_options[] = {
-     { "dir", "set transpose direction", OFFSET(dir), AV_OPT_TYPE_INT, {.i64=0},  0, 7, FLAGS },
-     { "passthrough", "do not apply transposition if the input matches the specified geometry",
-       OFFSET(passthrough), AV_OPT_TYPE_INT, {.i64=TRANSPOSE_PT_TYPE_NONE},  0, INT_MAX, FLAGS, "passthrough" },
-     { "none",      "always apply transposition",   0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_NONE},      INT_MIN, INT_MAX, FLAGS, "passthrough" },
-     { "portrait",  "preserve portrait geometry",   0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_PORTRAIT},  INT_MIN, INT_MAX, FLAGS, "passthrough" },
-     { "landscape", "preserve landscape geometry",  0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_LANDSCAPE}, INT_MIN, INT_MAX, FLAGS, "passthrough" },
-     { NULL },
- };
- AVFILTER_DEFINE_CLASS(transpose);
  static int query_formats(AVFilterContext *ctx)
  {
 -    enum AVPixelFormat pix_fmts[] = {
 -        AV_PIX_FMT_ARGB,         AV_PIX_FMT_RGBA,
 -        AV_PIX_FMT_ABGR,         AV_PIX_FMT_BGRA,
 -        AV_PIX_FMT_RGB24,        AV_PIX_FMT_BGR24,
 -        AV_PIX_FMT_RGB565BE,     AV_PIX_FMT_RGB565LE,
 -        AV_PIX_FMT_RGB555BE,     AV_PIX_FMT_RGB555LE,
 -        AV_PIX_FMT_BGR565BE,     AV_PIX_FMT_BGR565LE,
 -        AV_PIX_FMT_BGR555BE,     AV_PIX_FMT_BGR555LE,
 -        AV_PIX_FMT_GRAY16BE,     AV_PIX_FMT_GRAY16LE,
 -        AV_PIX_FMT_YUV420P16LE,  AV_PIX_FMT_YUV420P16BE,
 -        AV_PIX_FMT_YUV422P16LE,  AV_PIX_FMT_YUV422P16BE,
 -        AV_PIX_FMT_YUV444P16LE,  AV_PIX_FMT_YUV444P16BE,
 -        AV_PIX_FMT_NV12,         AV_PIX_FMT_NV21,
 -        AV_PIX_FMT_RGB8,         AV_PIX_FMT_BGR8,
 -        AV_PIX_FMT_RGB4_BYTE,    AV_PIX_FMT_BGR4_BYTE,
 -        AV_PIX_FMT_YUV444P,      AV_PIX_FMT_YUV422P,
 -        AV_PIX_FMT_YUV420P,      AV_PIX_FMT_YUVJ420P,
 -        AV_PIX_FMT_YUV411P,      AV_PIX_FMT_YUV410P,
 -        AV_PIX_FMT_YUVJ444P,     AV_PIX_FMT_YUVJ422P,
 -        AV_PIX_FMT_YUV440P,      AV_PIX_FMT_YUVJ440P,
 -        AV_PIX_FMT_YUVA420P,     AV_PIX_FMT_GRAY8,
 -        AV_PIX_FMT_NONE
 -    };
 -
 -    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 +    AVFilterFormats *pix_fmts = NULL;
 +    int fmt;
 +
 +    for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
 +        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
 +        if (!(desc->flags & PIX_FMT_PAL ||
 +              desc->flags & PIX_FMT_HWACCEL ||
 +              desc->flags & PIX_FMT_BITSTREAM ||
 +              desc->log2_chroma_w != desc->log2_chroma_h))
 +            ff_add_format(&pix_fmts, fmt);
 +    }
 +
 +
 +    ff_set_common_formats(ctx, pix_fmts);
      return 0;
  }
  
@@@ -236,6 -187,25 +223,28 @@@ static int filter_frame(AVFilterLink *i
      return ff_filter_frame(outlink, out);
  }
  
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
 -static const AVOption options[] = {
+ #define OFFSET(x) offsetof(TransContext, x)
 -static const AVClass transpose_class = {
 -    .class_name = "transpose",
 -    .item_name  = av_default_item_name,
 -    .option     = options,
 -    .version    = LIBAVUTIL_VERSION_INT,
 -};
++#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
++
++static const AVOption transpose_options[] = {
+     { "dir", "Transpose direction", OFFSET(dir), AV_OPT_TYPE_INT, { .i64 = TRANSPOSE_CCLOCK_FLIP },
+         TRANSPOSE_CCLOCK_FLIP, TRANSPOSE_CLOCK_FLIP, FLAGS, "dir" },
+         { "cclock_flip", "counter-clockwise with vertical flip", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK_FLIP }, .unit = "dir" },
+         { "clock",       "clockwise",                            0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK       }, .unit = "dir" },
+         { "cclock",      "counter-clockwise",                    0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK      }, .unit = "dir" },
+         { "clock_flip",  "clockwise with vertical flip",         0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK_FLIP  }, .unit = "dir" },
++
++    { "passthrough", "do not apply transposition if the input matches the specified geometry",
++      OFFSET(passthrough), AV_OPT_TYPE_INT, {.i64=TRANSPOSE_PT_TYPE_NONE},  0, INT_MAX, FLAGS, "passthrough" },
++    { "none",      "always apply transposition",   0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_NONE},      INT_MIN, INT_MAX, FLAGS, "passthrough" },
++    { "portrait",  "preserve portrait geometry",   0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_PORTRAIT},  INT_MIN, INT_MAX, FLAGS, "passthrough" },
++    { "landscape", "preserve landscape geometry",  0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_LANDSCAPE}, INT_MIN, INT_MAX, FLAGS, "passthrough" },
++
+     { NULL },
+ };
++AVFILTER_DEFINE_CLASS(transpose);
  static const AVFilterPad avfilter_vf_transpose_inputs[] = {
      {
          .name        = "default",