Merge commit '7e350379f87e7f74420b4813170fe808e2313911'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 10 Mar 2013 00:30:30 +0000 (01:30 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 10 Mar 2013 00:40:35 +0000 (01:40 +0100)
* commit '7e350379f87e7f74420b4813170fe808e2313911':
  lavfi: switch to AVFrame.

Conflicts:
doc/filters.texi
libavfilter/af_ashowinfo.c
libavfilter/audio.c
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/buffersink.c
libavfilter/buffersrc.c
libavfilter/buffersrc.h
libavfilter/f_select.c
libavfilter/f_setpts.c
libavfilter/fifo.c
libavfilter/split.c
libavfilter/src_movie.c
libavfilter/version.h
libavfilter/vf_aspect.c
libavfilter/vf_bbox.c
libavfilter/vf_blackframe.c
libavfilter/vf_delogo.c
libavfilter/vf_drawbox.c
libavfilter/vf_drawtext.c
libavfilter/vf_fade.c
libavfilter/vf_fieldorder.c
libavfilter/vf_fps.c
libavfilter/vf_frei0r.c
libavfilter/vf_gradfun.c
libavfilter/vf_hqdn3d.c
libavfilter/vf_lut.c
libavfilter/vf_overlay.c
libavfilter/vf_pad.c
libavfilter/vf_scale.c
libavfilter/vf_showinfo.c
libavfilter/vf_transpose.c
libavfilter/vf_vflip.c
libavfilter/vf_yadif.c
libavfilter/video.c
libavfilter/vsrc_testsrc.c
libavfilter/yadif.h

Following are notes about the merge authorship and various technical details.

Michael Niedermayer:
  * Main merge operation, notably avfilter.c and video.c
  * Switch to AVFrame:
    - afade
    - anullsrc
    - apad
    - aresample
    - blackframe
    - deshake
    - idet
    - il
    - mandelbrot
    - mptestsrc
    - noise
    - setfield
    - smartblur
    - tinterlace
  * various merge changes and fixes in:
    - ashowinfo
    - blackdetect
    - field
    - fps
    - select
    - testsrc
    - yadif

Nicolas George:
  * Switch to AVFrame:
    - make rawdec work with refcounted frames. Adapted from commit
      759001c534287a96dc96d1e274665feb7059145d by Anton Khirnov.
      Also, fix the use of || instead of | in a flags check.
    - make buffer sink and src, audio and video work all together

Clément Bœsch:
  * Switch to AVFrame:
    - aevalsrc
    - alphaextract
    - blend
    - cellauto
    - colormatrix
    - concat
    - earwax
    - ebur128
    - edgedetect
    - geq
    - histeq
    - histogram
    - hue
    - kerndeint
    - life
    - movie
    - mp (with the help of Michael)
    - overlay
    - pad
    - pan
    - pp
    - pp
    - removelogo
    - sendcmd
    - showspectrum
    - showwaves
    - silencedetect
    - stereo3d
    - subtitles
    - super2xsai
    - swapuv
    - thumbnail
    - tile

Hendrik Leppkes:
  * Switch to AVFrame:
    - aconvert
    - amerge
    - asetnsamples
    - atempo
    - biquads

Matthieu Bouron:
  * Switch to AVFrame
    - alphamerge
    - decimate
    - volumedetect

Stefano Sabatini:
  * Switch to AVFrame:
    - astreamsync
    - flite
    - framestep

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
Signed-off-by: Nicolas George <nicolas.george@normalesup.org>
Signed-off-by: Clément Bœsch <ubitux@gmail.com>
Signed-off-by: Hendrik Leppkes <h.leppkes@gmail.com>
Signed-off-by: Matthieu Bouron <matthieu.bouron@gmail.com>
Signed-off-by: Stefano Sabatini <stefasab@gmail.com>
Merged-by: Michael Niedermayer <michaelni@gmx.at>
122 files changed:
1  2 
doc/filters.texi
ffmpeg.c
libavfilter/Makefile
libavfilter/af_aconvert.c
libavfilter/af_afade.c
libavfilter/af_amerge.c
libavfilter/af_amix.c
libavfilter/af_apad.c
libavfilter/af_aresample.c
libavfilter/af_asetnsamples.c
libavfilter/af_ashowinfo.c
libavfilter/af_astreamsync.c
libavfilter/af_asyncts.c
libavfilter/af_atempo.c
libavfilter/af_biquads.c
libavfilter/af_channelmap.c
libavfilter/af_channelsplit.c
libavfilter/af_earwax.c
libavfilter/af_join.c
libavfilter/af_pan.c
libavfilter/af_silencedetect.c
libavfilter/af_volume.c
libavfilter/af_volumedetect.c
libavfilter/allfilters.c
libavfilter/asink_anullsink.c
libavfilter/asrc_aevalsrc.c
libavfilter/asrc_anullsrc.c
libavfilter/asrc_flite.c
libavfilter/audio.c
libavfilter/audio.h
libavfilter/avcodec.c
libavfilter/avcodec.h
libavfilter/avf_concat.c
libavfilter/avf_showspectrum.c
libavfilter/avf_showwaves.c
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/buffer.c
libavfilter/bufferqueue.h
libavfilter/buffersink.c
libavfilter/buffersink.h
libavfilter/buffersrc.c
libavfilter/buffersrc.h
libavfilter/f_ebur128.c
libavfilter/f_select.c
libavfilter/f_sendcmd.c
libavfilter/f_setpts.c
libavfilter/f_settb.c
libavfilter/fifo.c
libavfilter/internal.h
libavfilter/sink_buffer.c
libavfilter/split.c
libavfilter/src_movie.c
libavfilter/version.h
libavfilter/vf_alphaextract.c
libavfilter/vf_alphamerge.c
libavfilter/vf_aspect.c
libavfilter/vf_bbox.c
libavfilter/vf_blackdetect.c
libavfilter/vf_blackframe.c
libavfilter/vf_blend.c
libavfilter/vf_boxblur.c
libavfilter/vf_colormatrix.c
libavfilter/vf_copy.c
libavfilter/vf_crop.c
libavfilter/vf_cropdetect.c
libavfilter/vf_decimate.c
libavfilter/vf_delogo.c
libavfilter/vf_deshake.c
libavfilter/vf_drawbox.c
libavfilter/vf_drawtext.c
libavfilter/vf_edgedetect.c
libavfilter/vf_fade.c
libavfilter/vf_field.c
libavfilter/vf_fieldorder.c
libavfilter/vf_fps.c
libavfilter/vf_framestep.c
libavfilter/vf_frei0r.c
libavfilter/vf_geq.c
libavfilter/vf_gradfun.c
libavfilter/vf_hflip.c
libavfilter/vf_histeq.c
libavfilter/vf_histogram.c
libavfilter/vf_hqdn3d.c
libavfilter/vf_hue.c
libavfilter/vf_idet.c
libavfilter/vf_il.c
libavfilter/vf_kerndeint.c
libavfilter/vf_libopencv.c
libavfilter/vf_lut.c
libavfilter/vf_mp.c
libavfilter/vf_noise.c
libavfilter/vf_overlay.c
libavfilter/vf_pad.c
libavfilter/vf_pixdesctest.c
libavfilter/vf_pp.c
libavfilter/vf_removelogo.c
libavfilter/vf_scale.c
libavfilter/vf_setfield.c
libavfilter/vf_showinfo.c
libavfilter/vf_smartblur.c
libavfilter/vf_stereo3d.c
libavfilter/vf_subtitles.c
libavfilter/vf_super2xsai.c
libavfilter/vf_swapuv.c
libavfilter/vf_thumbnail.c
libavfilter/vf_tile.c
libavfilter/vf_tinterlace.c
libavfilter/vf_transpose.c
libavfilter/vf_unsharp.c
libavfilter/vf_vflip.c
libavfilter/vf_yadif.c
libavfilter/video.c
libavfilter/video.h
libavfilter/vsink_nullsink.c
libavfilter/vsrc_cellauto.c
libavfilter/vsrc_life.c
libavfilter/vsrc_mandelbrot.c
libavfilter/vsrc_mptestsrc.c
libavfilter/vsrc_testsrc.c
libavfilter/yadif.h
libavutil/frame.c

@@@ -2070,3954 -619,1069 +2070,3951 @@@ the output (cropped) width and heigh
  @item ow, oh
  same as @var{out_w} and @var{out_h}
  
 -@item n
 -the number of input frame, starting from 0
 +@item a
 +same as @var{iw} / @var{ih}
 +
 +@item sar
 +input sample aspect ratio
 +
 +@item dar
 +input display aspect ratio, it is the same as (@var{iw} / @var{ih}) * @var{sar}
 +
 +@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 n
 +the number of input frame, starting from 0
 +
- @item pos
- the position in the file of the input frame, NAN if unknown
 +@item t
 +timestamp expressed in seconds, NAN if the input timestamp is unknown
 +
 +@end table
 +
 +The expression for @var{out_w} may depend on the value of @var{out_h},
 +and the expression for @var{out_h} may depend on @var{out_w}, but they
 +cannot depend on @var{x} and @var{y}, as @var{x} and @var{y} are
 +evaluated after @var{out_w} and @var{out_h}.
 +
 +The @var{x} and @var{y} parameters specify the expressions for the
 +position of the top-left corner of the output (non-cropped) area. They
 +are evaluated for each frame. If the evaluated value is not valid, it
 +is approximated to the nearest valid value.
 +
 +The expression for @var{x} may depend on @var{y}, and the expression
 +for @var{y} may depend on @var{x}.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Crop area with size 100x100 at position (12,34).
 +@example
 +crop=100:100:12:34
 +@end example
 +
 +Using named options, the example above becomes:
 +@example
 +crop=w=100:h=100:x=12:y=34
 +@end example
 +
 +@item
 +Crop the central input area with size 100x100:
 +@example
 +crop=100:100
 +@end example
 +
 +@item
 +Crop the central input area with size 2/3 of the input video:
 +@example
 +crop=2/3*in_w:2/3*in_h
 +@end example
 +
 +@item
 +Crop the input video central square:
 +@example
 +crop=in_h
 +@end example
 +
 +@item
 +Delimit the rectangle with the top-left corner placed at position
 +100:100 and the right-bottom corner corresponding to the right-bottom
 +corner of the input image:
 +@example
 +crop=in_w-100:in_h-100:100:100
 +@end example
 +
 +@item
 +Crop 10 pixels from the left and right borders, and 20 pixels from
 +the top and bottom borders
 +@example
 +crop=in_w-2*10:in_h-2*20
 +@end example
 +
 +@item
 +Keep only the bottom right quarter of the input image:
 +@example
 +crop=in_w/2:in_h/2:in_w/2:in_h/2
 +@end example
 +
 +@item
 +Crop height for getting Greek harmony:
 +@example
 +crop=in_w:1/PHI*in_w
 +@end example
 +
 +@item
 +Appply trembling effect:
 +@example
 +crop=in_w/2:in_h/2:(in_w-out_w)/2+((in_w-out_w)/2)*sin(n/10):(in_h-out_h)/2 +((in_h-out_h)/2)*sin(n/7)
 +@end example
 +
 +@item
 +Apply erratic camera effect depending on timestamp:
 +@example
 +crop=in_w/2:in_h/2:(in_w-out_w)/2+((in_w-out_w)/2)*sin(t*10):(in_h-out_h)/2 +((in_h-out_h)/2)*sin(t*13)"
 +@end example
 +
 +@item
 +Set x depending on the value of y:
 +@example
 +crop=in_w/2:in_h/2:y:10+10*sin(n/10)
 +@end example
 +@end itemize
 +
 +@section cropdetect
 +
 +Auto-detect crop size.
 +
 +Calculate necessary cropping parameters and prints the recommended
 +parameters through the logging system. The detected dimensions
 +correspond to the non-black area of the input video.
 +
 +It accepts the syntax:
 +@example
 +cropdetect[=@var{limit}[:@var{round}[:@var{reset}]]]
 +@end example
 +
 +@table @option
 +
 +@item limit
 +Threshold, which can be optionally specified from nothing (0) to
 +everything (255), defaults to 24.
 +
 +@item round
 +Value which the width/height should be divisible by, defaults to
 +16. The offset is automatically adjusted to center the video. Use 2 to
 +get only even dimensions (needed for 4:2:2 video). 16 is best when
 +encoding to most video codecs.
 +
 +@item reset
 +Counter that determines after how many frames cropdetect will reset
 +the previously detected largest video area and start over to detect
 +the current optimal crop area. Defaults to 0.
 +
 +This can be useful when channel logos distort the video area. 0
 +indicates never reset and return the largest area encountered during
 +playback.
 +@end table
 +
 +@section decimate
 +
 +Drop frames that do not differ greatly from the previous frame in
 +order to reduce framerate.
 +
 +The main use of this filter is for very-low-bitrate encoding
 +(e.g. streaming over dialup modem), but it could in theory be used for
 +fixing movies that were inverse-telecined incorrectly.
 +
 +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:
 +@option{max}:@option{hi}:@option{lo}:@option{frac}.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item max
 +Set the maximum number of consecutive frames which can be dropped (if
 +positive), or the minimum interval between dropped frames (if
 +negative). If the value is 0, the frame is dropped unregarding the
 +number of previous sequentially dropped frames.
 +
 +Default value is 0.
 +
 +@item hi
 +@item lo
 +@item frac
 +Set the dropping threshold values.
 +
 +Values for @option{hi} and @option{lo} are for 8x8 pixel blocks and
 +represent actual pixel value differences, so a threshold of 64
 +corresponds to 1 unit of difference for each pixel, or the same spread
 +out differently over the block.
 +
 +A frame is a candidate for dropping if no 8x8 blocks differ by more
 +than a threshold of @option{hi}, and if no more than @option{frac} blocks (1
 +meaning the whole image) differ by more than a threshold of @option{lo}.
 +
 +Default value for @option{hi} is 64*12, default value for @option{lo} is
 +64*5, and default value for @option{frac} is 0.33.
 +@end table
 +
 +@section delogo
 +
 +Suppress a TV station logo by a simple interpolation of the surrounding
 +pixels. Just set a rectangle covering the logo and watch it disappear
 +(and sometimes something even uglier appear - your mileage may vary).
 +
 +The filter accepts parameters as a string of the form
 +"@var{x}:@var{y}:@var{w}:@var{h}:@var{band}", or as a list of
 +@var{key}=@var{value} pairs, separated by ":".
 +
 +The description of the accepted parameters follows.
 +
 +@table @option
 +
 +@item x, y
 +Specify the top left corner coordinates of the logo. They must be
 +specified.
 +
 +@item w, h
 +Specify the width and height of the logo to clear. They must be
 +specified.
 +
 +@item band, t
 +Specify the thickness of the fuzzy edge of the rectangle (added to
 +@var{w} and @var{h}). The default value is 4.
 +
 +@item show
 +When set to 1, a green rectangle is drawn on the screen to simplify
 +finding the right @var{x}, @var{y}, @var{w}, @var{h} parameters, and
 +@var{band} is set to 4. The default value is 0.
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Set a rectangle covering the area with top left corner coordinates 0,0
 +and size 100x77, setting a band of size 10:
 +@example
 +delogo=0:0:100:77:10
 +@end example
 +
 +@item
 +As the previous example, but use named options:
 +@example
 +delogo=x=0:y=0:w=100:h=77:band=10
 +@end example
 +
 +@end itemize
 +
 +@section deshake
 +
 +Attempt to fix small changes in horizontal and/or vertical shift. This
 +filter helps remove camera shake from hand-holding a camera, bumping a
 +tripod, moving on a vehicle, etc.
 +
 +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{x}:@var{y}:@var{w}:@var{h}:@var{rx}:@var{ry}:@var{edge}:@var{blocksize}:@var{contrast}:@var{search}:@var{filename}.
 +
 +A description of the accepted parameters follows.
 +
 +@table @option
 +
 +@item x, y, w, h
 +Specify a rectangular area where to limit the search for motion
 +vectors.
 +If desired the search for motion vectors can be limited to a
 +rectangular area of the frame defined by its top left corner, width
 +and height. These parameters have the same meaning as the drawbox
 +filter which can be used to visualise the position of the bounding
 +box.
 +
 +This is useful when simultaneous movement of subjects within the frame
 +might be confused for camera motion by the motion vector search.
 +
 +If any or all of @var{x}, @var{y}, @var{w} and @var{h} are set to -1
 +then the full frame is used. This allows later options to be set
 +without specifying the bounding box for the motion vector search.
 +
 +Default - search the whole frame.
 +
 +@item rx, ry
 +Specify the maximum extent of movement in x and y directions in the
 +range 0-64 pixels. Default 16.
 +
 +@item edge
 +Specify how to generate pixels to fill blanks at the edge of the
 +frame. Available values are:
 +@table @samp
 +@item blank, 0
 +Fill zeroes at blank locations
 +@item original, 1
 +Original image at blank locations
 +@item clamp, 2
 +Extruded edge value at blank locations
 +@item mirror, 3
 +Mirrored edge at blank locations
 +@end table
 +Default value is @samp{mirror}.
 +
 +@item blocksize
 +Specify the blocksize to use for motion search. Range 4-128 pixels,
 +default 8.
 +
 +@item contrast
 +Specify the contrast threshold for blocks. Only blocks with more than
 +the specified contrast (difference between darkest and lightest
 +pixels) will be considered. Range 1-255, default 125.
 +
 +@item search
 +Specify the search strategy. Available values are:
 +@table @samp
 +@item exhaustive, 0
 +Set exhaustive search
 +@item less, 1
 +Set less exhaustive search.
 +@end table
 +Default value is @samp{exhaustive}.
 +
 +@item filename
 +If set then a detailed log of the motion search is written to the
 +specified file.
 +
 +@end table
 +
 +@section drawbox
 +
 +Draw a colored box on the input image.
 +
 +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
 +@option{x}:@option{y}:@option{width}:@option{height}:@option{color}:@option{thickness}.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item x, y
 +Specify the top left corner coordinates of the box. Default to 0.
 +
 +@item width, w
 +@item height, h
 +Specify the width and height of the box, if 0 they are interpreted as
 +the input width and height. Default to 0.
 +
 +@item color, c
 +Specify the color of the box to write, it can be the name of a color
 +(case insensitive match) or a 0xRRGGBB[AA] sequence. If the special
 +value @code{invert} is used, the box edge color is the same as the
 +video with inverted luma.
 +
 +@item thickness, t
 +Set the thickness of the box edge. Default value is @code{4}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Draw a black box around the edge of the input image:
 +@example
 +drawbox
 +@end example
 +
 +@item
 +Draw a box with color red and an opacity of 50%:
 +@example
 +drawbox=10:20:200:60:red@@0.5
 +@end example
 +
 +The previous example can be specified as:
 +@example
 +drawbox=x=10:y=20:w=200:h=60:color=red@@0.5
 +@end example
 +
 +@item
 +Fill the box with pink color:
 +@example
 +drawbox=x=10:y=10:w=100:h=100:color=pink@@0.5:t=max
 +@end example
 +@end itemize
 +
 +@anchor{drawtext}
 +@section drawtext
 +
 +Draw text string or text from specified file on top of video using the
 +libfreetype library.
 +
 +To enable compilation of this filter you need to configure FFmpeg with
 +@code{--enable-libfreetype}.
 +
 +@subsection Syntax
 +
 +The filter accepts parameters as a list of @var{key}=@var{value} pairs,
 +separated by ":".
 +
 +The description of the accepted parameters follows.
 +
 +@table @option
 +
 +@item box
 +Used to draw a box around text using background color.
 +Value should be either 1 (enable) or 0 (disable).
 +The default value of @var{box} is 0.
 +
 +@item boxcolor
 +The color to be used for drawing box around text.
 +Either a string (e.g. "yellow") or in 0xRRGGBB[AA] format
 +(e.g. "0xff00ff"), possibly followed by an alpha specifier.
 +The default value of @var{boxcolor} is "white".
 +
 +@item draw
 +Set an expression which specifies if the text should be drawn. If the
 +expression evaluates to 0, the text is not drawn. This is useful for
 +specifying that the text should be drawn only when specific conditions
 +are met.
 +
 +Default value is "1".
 +
 +See below for the list of accepted constants and functions.
 +
 +@item expansion
 +Select how the @var{text} is expanded. Can be either @code{none},
 +@code{strftime} (deprecated) or
 +@code{normal} (default). See the @ref{drawtext_expansion, Text expansion} section
 +below for details.
 +
 +@item fix_bounds
 +If true, check and fix text coords to avoid clipping.
 +
 +@item fontcolor
 +The color to be used for drawing fonts.
 +Either a string (e.g. "red") or in 0xRRGGBB[AA] format
 +(e.g. "0xff000033"), possibly followed by an alpha specifier.
 +The default value of @var{fontcolor} is "black".
 +
 +@item fontfile
 +The font file to be used for drawing text. Path must be included.
 +This parameter is mandatory.
 +
 +@item fontsize
 +The font size to be used for drawing text.
 +The default value of @var{fontsize} is 16.
 +
 +@item ft_load_flags
 +Flags to be used for loading the fonts.
 +
 +The flags map the corresponding flags supported by libfreetype, and are
 +a combination of the following values:
 +@table @var
 +@item default
 +@item no_scale
 +@item no_hinting
 +@item render
 +@item no_bitmap
 +@item vertical_layout
 +@item force_autohint
 +@item crop_bitmap
 +@item pedantic
 +@item ignore_global_advance_width
 +@item no_recurse
 +@item ignore_transform
 +@item monochrome
 +@item linear_design
 +@item no_autohint
 +@item end table
 +@end table
 +
 +Default value is "render".
 +
 +For more information consult the documentation for the FT_LOAD_*
 +libfreetype flags.
 +
 +@item shadowcolor
 +The color to be used for drawing a shadow behind the drawn text.  It
 +can be a color name (e.g. "yellow") or a string in the 0xRRGGBB[AA]
 +form (e.g. "0xff00ff"), possibly followed by an alpha specifier.
 +The default value of @var{shadowcolor} is "black".
 +
 +@item shadowx, shadowy
 +The x and y offsets for the text shadow position with respect to the
 +position of the text. They can be either positive or negative
 +values. Default value for both is "0".
 +
 +@item tabsize
 +The size in number of spaces to use for rendering the tab.
 +Default value is 4.
 +
 +@item timecode
 +Set the initial timecode representation in "hh:mm:ss[:;.]ff"
 +format. It can be used with or without text parameter. @var{timecode_rate}
 +option must be specified.
 +
 +@item timecode_rate, rate, r
 +Set the timecode frame rate (timecode only).
 +
 +@item text
 +The text string to be drawn. The text must be a sequence of UTF-8
 +encoded characters.
 +This parameter is mandatory if no file is specified with the parameter
 +@var{textfile}.
 +
 +@item textfile
 +A text file containing text to be drawn. The text must be a sequence
 +of UTF-8 encoded characters.
 +
 +This parameter is mandatory if no text string is specified with the
 +parameter @var{text}.
 +
 +If both @var{text} and @var{textfile} are specified, an error is thrown.
 +
 +@item reload
 +If set to 1, the @var{textfile} will be reloaded before each frame.
 +Be sure to update it atomically, or it may be read partially, or even fail.
 +
 +@item x, y
 +The expressions which specify the offsets where text will be drawn
 +within the video frame. They are relative to the top/left border of the
 +output image.
 +
 +The default value of @var{x} and @var{y} is "0".
 +
 +See below for the list of accepted constants and functions.
 +@end table
 +
 +The parameters for @var{x} and @var{y} are expressions containing the
 +following constants and functions:
 +
 +@table @option
 +@item dar
 +input display aspect ratio, it is the same as (@var{w} / @var{h}) * @var{sar}
 +
 +@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 line_h, lh
 +the height of each text line
 +
 +@item main_h, h, H
 +the input height
 +
 +@item main_w, w, W
 +the input width
 +
 +@item max_glyph_a, ascent
 +the maximum distance from the baseline to the highest/upper grid
 +coordinate used to place a glyph outline point, for all the rendered
 +glyphs.
 +It is a positive value, due to the grid's orientation with the Y axis
 +upwards.
 +
 +@item max_glyph_d, descent
 +the maximum distance from the baseline to the lowest grid coordinate
 +used to place a glyph outline point, for all the rendered glyphs.
 +This is a negative value, due to the grid's orientation, with the Y axis
 +upwards.
 +
 +@item max_glyph_h
 +maximum glyph height, that is the maximum height for all the glyphs
 +contained in the rendered text, it is equivalent to @var{ascent} -
 +@var{descent}.
 +
 +@item max_glyph_w
 +maximum glyph width, that is the maximum width for all the glyphs
 +contained in the rendered text
 +
 +@item n
 +the number of input frame, starting from 0
 +
 +@item rand(min, max)
 +return a random number included between @var{min} and @var{max}
 +
 +@item sar
 +input sample aspect ratio
 +
 +@item t
 +timestamp expressed in seconds, NAN if the input timestamp is unknown
 +
 +@item text_h, th
 +the height of the rendered text
 +
 +@item text_w, tw
 +the width of the rendered text
 +
 +@item x, y
 +the x and y offset coordinates where the text is drawn.
 +
 +These parameters allow the @var{x} and @var{y} expressions to refer
 +each other, so you can for example specify @code{y=x/dar}.
 +@end table
 +
 +If libavfilter was built with @code{--enable-fontconfig}, then
 +@option{fontfile} can be a fontconfig pattern or omitted.
 +
 +@anchor{drawtext_expansion}
 +@subsection Text expansion
 +
 +If @option{expansion} is set to @code{strftime},
 +the filter recognizes strftime() sequences in the provided text and
 +expands them accordingly. Check the documentation of strftime(). This
 +feature is deprecated.
 +
 +If @option{expansion} is set to @code{none}, the text is printed verbatim.
 +
 +If @option{expansion} is set to @code{normal} (which is the default),
 +the following expansion mechanism is used.
 +
 +The backslash character '\', followed by any character, always expands to
 +the second character.
 +
 +Sequence of the form @code{%@{...@}} are expanded. The text between the
 +braces is a function name, possibly followed by arguments separated by ':'.
 +If the arguments contain special characters or delimiters (':' or '@}'),
 +they should be escaped.
 +
 +Note that they probably must also be escaped as the value for the
 +@option{text} option in the filter argument string and as the filter
 +argument in the filter graph description, and possibly also for the shell,
 +that makes up to four levels of escaping; using a text file avoids these
 +problems.
 +
 +The following functions are available:
 +
 +@table @command
 +
 +@item expr, e
 +The expression evaluation result.
 +
 +It must take one argument specifying the expression to be evaluated,
 +which accepts the same constants and functions as the @var{x} and
 +@var{y} values. Note that not all constants should be used, for
 +example the text size is not known when evaluating the expression, so
 +the constants @var{text_w} and @var{text_h} will have an undefined
 +value.
 +
 +@item gmtime
 +The time at which the filter is running, expressed in UTC.
 +It can accept an argument: a strftime() format string.
 +
 +@item localtime
 +The time at which the filter is running, expressed in the local time zone.
 +It can accept an argument: a strftime() format string.
 +
 +@item n, frame_num
 +The frame number, starting from 0.
 +
 +@item pts
 +The timestamp of the current frame, in seconds, with microsecond accuracy.
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Draw "Test Text" with font FreeSerif, using the default values for the
 +optional parameters.
 +
 +@example
 +drawtext="fontfile=/usr/share/fonts/truetype/freefont/FreeSerif.ttf: text='Test Text'"
 +@end example
 +
 +@item
 +Draw 'Test Text' with font FreeSerif of size 24 at position x=100
 +and y=50 (counting from the top-left corner of the screen), text is
 +yellow with a red box around it. Both the text and the box have an
 +opacity of 20%.
 +
 +@example
 +drawtext="fontfile=/usr/share/fonts/truetype/freefont/FreeSerif.ttf: text='Test Text':\
 +          x=100: y=50: fontsize=24: fontcolor=yellow@@0.2: box=1: boxcolor=red@@0.2"
 +@end example
 +
 +Note that the double quotes are not necessary if spaces are not used
 +within the parameter list.
 +
 +@item
 +Show the text at the center of the video frame:
 +@example
 +drawtext="fontsize=30:fontfile=FreeSerif.ttf:text='hello world':x=(w-text_w)/2:y=(h-text_h-line_h)/2"
 +@end example
 +
 +@item
 +Show a text line sliding from right to left in the last row of the video
 +frame. The file @file{LONG_LINE} is assumed to contain a single line
 +with no newlines.
 +@example
 +drawtext="fontsize=15:fontfile=FreeSerif.ttf:text=LONG_LINE:y=h-line_h:x=-50*t"
 +@end example
 +
 +@item
 +Show the content of file @file{CREDITS} off the bottom of the frame and scroll up.
 +@example
 +drawtext="fontsize=20:fontfile=FreeSerif.ttf:textfile=CREDITS:y=h-20*t"
 +@end example
 +
 +@item
 +Draw a single green letter "g", at the center of the input video.
 +The glyph baseline is placed at half screen height.
 +@example
 +drawtext="fontsize=60:fontfile=FreeSerif.ttf:fontcolor=green:text=g:x=(w-max_glyph_w)/2:y=h/2-ascent"
 +@end example
 +
 +@item
 +Show text for 1 second every 3 seconds:
 +@example
 +drawtext="fontfile=FreeSerif.ttf:fontcolor=white:x=100:y=x/dar:draw=lt(mod(t\,3)\,1):text='blink'"
 +@end example
 +
 +@item
 +Use fontconfig to set the font. Note that the colons need to be escaped.
 +@example
 +drawtext='fontfile=Linux Libertine O-40\:style=Semibold:text=FFmpeg'
 +@end example
 +
 +@item
 +Print the date of a real-time encoding (see strftime(3)):
 +@example
 +drawtext='fontfile=FreeSans.ttf:text=%@{localtime:%a %b %d %Y@}'
 +@end example
 +
 +@end itemize
 +
 +For more information about libfreetype, check:
 +@url{http://www.freetype.org/}.
 +
 +For more information about fontconfig, check:
 +@url{http://freedesktop.org/software/fontconfig/fontconfig-user.html}.
 +
 +@section edgedetect
 +
 +Detect and draw edges. The filter uses the Canny Edge Detection algorithm.
 +
 +This filter accepts the following optional named parameters:
 +
 +@table @option
 +@item low, high
 +Set low and high threshold values used by the Canny thresholding
 +algorithm.
 +
 +The high threshold selects the "strong" edge pixels, which are then
 +connected through 8-connectivity with the "weak" edge pixels selected
 +by the low threshold.
 +
 +@var{low} and @var{high} threshold values must be choosen in the range
 +[0,1], and @var{low} should be lesser or equal to @var{high}.
 +
 +Default value for @var{low} is @code{20/255}, and default value for @var{high}
 +is @code{50/255}.
 +@end table
 +
 +Example:
 +@example
 +edgedetect=low=0.1:high=0.4
 +@end example
 +
 +@section fade
 +
 +Apply fade-in/out effect to input video.
 +
 +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{type}:@var{start_frame}:@var{nb_frames}.
 +
 +A description of the accepted parameters follows.
 +
 +@table @option
 +@item type, t
 +Specify if the effect type, can be either @code{in} for fade-in, or
 +@code{out} for a fade-out effect. Default is @code{in}.
 +
 +@item start_frame, s
 +Specify the number of the start frame for starting to apply the fade
 +effect. Default is 0.
 +
 +@item nb_frames, n
 +Specify the number of frames for which the fade effect has to last. At
 +the end of the fade-in effect the output video will have the same
 +intensity as the input video, at the end of the fade-out transition
 +the output video will be completely black. Default is 25.
 +
 +@item alpha
 +If set to 1, fade only alpha channel, if one exists on the input.
 +Default value is 0.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Fade in first 30 frames of video:
 +@example
 +fade=in:0:30
 +@end example
 +
 +The command above is equivalent to:
 +@example
 +fade=t=in:s=0:n=30
 +@end example
 +
 +@item
 +Fade out last 45 frames of a 200-frame video:
 +@example
 +fade=out:155:45
 +@end example
 +
 +@item
 +Fade in first 25 frames and fade out last 25 frames of a 1000-frame video:
 +@example
 +fade=in:0:25, fade=out:975:25
 +@end example
 +
 +@item
 +Make first 5 frames black, then fade in from frame 5-24:
 +@example
 +fade=in:5:20
 +@end example
 +
 +@item
 +Fade in alpha over first 25 frames of video:
 +@example
 +fade=in:0:25:alpha=1
 +@end example
 +@end itemize
 +
 +@section field
 +
 +Extract a single field from an interlaced image using stride
 +arithmetic to avoid wasting CPU time. The output frames are marked as
 +non-interlaced.
 +
 +This filter accepts the following named options:
 +@table @option
 +@item type
 +Specify whether to extract the top (if the value is @code{0} or
 +@code{top}) or the bottom field (if the value is @code{1} or
 +@code{bottom}).
 +@end table
 +
 +If the option key is not specified, the first value sets the @var{type}
 +option. For example:
 +@example
 +field=bottom
 +@end example
 +
 +is equivalent to:
 +@example
 +field=type=bottom
 +@end example
 +
 +@section fieldorder
 +
 +Transform the field order of the input video.
 +
 +It accepts one parameter which specifies the required field order that
 +the input interlaced video will be transformed to. The parameter can
 +assume one of the following values:
 +
 +@table @option
 +@item 0 or bff
 +output bottom field first
 +@item 1 or tff
 +output top field first
 +@end table
 +
 +Default value is "tff".
 +
 +Transformation is achieved by shifting the picture content up or down
 +by one line, and filling the remaining line with appropriate picture content.
 +This method is consistent with most broadcast field order converters.
 +
 +If the input video is not flagged as being interlaced, or it is already
 +flagged as being of the required output field order then this filter does
 +not alter the incoming video.
 +
 +This filter is very useful when converting to or from PAL DV material,
 +which is bottom field first.
 +
 +For example:
 +@example
 +ffmpeg -i in.vob -vf "fieldorder=bff" out.dv
 +@end example
 +
 +@section fifo
 +
 +Buffer input images and send them when they are requested.
 +
 +This filter is mainly useful when auto-inserted by the libavfilter
 +framework.
 +
 +The filter does not take parameters.
 +
 +@section format
 +
 +Convert the input video to one of the specified pixel formats.
 +Libavfilter will try to pick one that is supported for the input to
 +the next filter.
 +
 +The filter accepts a list of pixel format names, separated by ":",
 +for example "yuv420p:monow:rgb24".
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Convert the input video to the format @var{yuv420p}
 +@example
 +format=yuv420p
 +@end example
 +
 +Convert the input video to any of the formats in the list
 +@example
 +format=yuv420p:yuv444p:yuv410p
 +@end example
 +@end itemize
 +
 +@section fps
 +
 +Convert the video to specified constant framerate by duplicating or dropping
 +frames as necessary.
 +
 +This filter accepts the following named parameters:
 +@table @option
 +
 +@item fps
 +Desired output framerate. The default is @code{25}.
 +
 +@item round
 +Rounding method.
 +
 +Possible values are:
 +@table @option
 +@item zero
 +zero round towards 0
 +@item inf
 +round away from 0
 +@item down
 +round towards -infinity
 +@item up
 +round towards +infinity
 +@item near
 +round to nearest
 +@end table
 +The default is @code{near}.
 +
 +@end table
 +
 +Alternatively, the options can be specified as a flat string:
 +@var{fps}[:@var{round}].
 +
 +See also the @ref{setpts} filter.
 +
 +@section framestep
 +
 +Select one frame every N.
 +
 +This filter accepts in input a string representing a positive
 +integer. Default argument is @code{1}.
 +
 +@anchor{frei0r}
 +@section frei0r
 +
 +Apply a frei0r effect to the input video.
 +
 +To enable compilation of this filter you need to install the frei0r
 +header and configure FFmpeg with @code{--enable-frei0r}.
 +
 +The filter supports the syntax:
 +@example
 +@var{filter_name}[@{:|=@}@var{param1}:@var{param2}:...:@var{paramN}]
 +@end example
 +
 +@var{filter_name} is the name of 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 (or
 +semicolon on Windows platforms) 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/}.
 +
 +@var{param1}, @var{param2}, ... , @var{paramN} specify the parameters
 +for the frei0r effect.
 +
 +A frei0r effect parameter can be a boolean (whose values are specified
 +with "y" and "n"), a double, a color (specified by the syntax
 +@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.
 +
 +The number and kind of parameters depend on the loaded effect. If an
 +effect parameter is not specified the default value is set.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply the distort0r effect, set the first two double parameters:
 +@example
 +frei0r=distort0r:0.5:0.01
 +@end example
 +
 +@item
 +Apply the colordistance effect, take a color as first parameter:
 +@example
 +frei0r=colordistance:0.2/0.3/0.4
 +frei0r=colordistance:violet
 +frei0r=colordistance:0x112233
 +@end example
 +
 +@item
 +Apply the perspective effect, specify the top left and top right image
 +positions:
 +@example
 +frei0r=perspective:0.2/0.2:0.8/0.2
 +@end example
 +@end itemize
 +
 +For more information see:
 +@url{http://frei0r.dyne.org}
 +
 +@section geq
 +
 +The filter takes one, two, three or four equations as parameter, separated by ':'.
 +The first equation is mandatory and applies to the luma plane. The two
 +following are respectively for chroma blue and chroma red planes.
 +
 +The filter syntax allows named parameters:
 +
 +@table @option
 +@item lum_expr
 +the luminance expression
 +@item cb_expr
 +the chrominance blue expression
 +@item cr_expr
 +the chrominance red expression
 +@item alpha_expr
 +the alpha expression
 +@end table
 +
 +If one of the chrominance expression is not defined, it falls back on the other
 +one. If no alpha expression is specified it will evaluate to opaque value.
 +If none of chrominance expressions are
 +specified, they will evaluate the luminance expression.
 +
 +The expressions can use the following variables and functions:
 +
 +@table @option
 +@item N
 +The sequential number of the filtered frame, starting from @code{0}.
 +
 +@item X, Y
 +The coordinates of the current sample.
 +
 +@item W, H
 +The width and height of the image.
 +
 +@item SW, SH
 +Width and height scale depending on the currently filtered plane. It is the
 +ratio between the corresponding luma plane number of pixels and the current
 +plane ones. E.g. for YUV4:2:0 the values are @code{1,1} for the luma plane, and
 +@code{0.5,0.5} for chroma planes.
 +
 +@item T
 +Time of the current frame, expressed in seconds.
 +
 +@item p(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the current
 +plane.
 +
 +@item lum(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the luminance
 +plane.
 +
 +@item cb(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the
 +blue-difference chroma plane. Returns 0 if there is no such plane.
 +
 +@item cr(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the
 +red-difference chroma plane. Returns 0 if there is no such plane.
 +
 +@item alpha(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the alpha
 +plane. Returns 0 if there is no such plane.
 +@end table
 +
 +For functions, if @var{x} and @var{y} are outside the area, the value will be
 +automatically clipped to the closer edge.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Flip the image horizontally:
 +@example
 +geq=p(W-X\,Y)
 +@end example
 +
 +@item
 +Generate a bidimensional sine wave, with angle @code{PI/3} and a
 +wavelength of 100 pixels:
 +@example
 +geq=128 + 100*sin(2*(PI/100)*(cos(PI/3)*(X-50*T) + sin(PI/3)*Y)):128:128
 +@end example
 +
 +@item
 +Generate a fancy enigmatic moving light:
 +@example
 +nullsrc=s=256x256,geq=random(1)/hypot(X-cos(N*0.07)*W/2-W/2\,Y-sin(N*0.09)*H/2-H/2)^2*1000000*sin(N*0.02):128:128
 +@end example
 +@end itemize
 +
 +@section gradfun
 +
 +Fix the banding artifacts that are sometimes introduced into nearly flat
 +regions by truncation to 8bit color depth.
 +Interpolate the gradients that should go where the bands are, and
 +dither them.
 +
 +This filter is designed for playback only.  Do not use it prior to
 +lossy compression, because compression tends to lose the dither and
 +bring back the bands.
 +
 +The filter 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
 +
 +@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 @code{0.51} to @code{64}, default value
 +is @code{1.2}.
 +
 +@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
 +@code{8-32}, default value is @code{16}.
 +
 +@end table
 +
 +Alternatively, the options can be specified as a flat string:
 +@var{strength}[:@var{radius}]
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply the filter with a @code{3.5} strength and radius of @code{8}:
 +@example
 +gradfun=3.5:8
 +@end example
 +
 +@item
 +Specify radius, omitting the strength (which will fall-back to the default
 +value):
 +@example
 +gradfun=radius=8
 +@end example
 +
 +@end itemize
 +
 +@section hflip
 +
 +Flip the input video horizontally.
 +
 +For example to horizontally flip the input video with @command{ffmpeg}:
 +@example
 +ffmpeg -i in.avi -vf "hflip" out.avi
 +@end example
 +
 +@section histeq
 +This filter applies a global color histogram equalization on a
 +per-frame basis.
 +
 +It can be used to correct video that has a compressed range of pixel
 +intensities.  The filter redistributes the pixel intensities to
 +equalize their distribution across the intensity range. It may be
 +viewed as an "automatically adjusting contrast filter". This filter is
 +useful only for correcting degraded or poorly captured source
 +video.
 +
 +The filter accepts 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{strength}:@var{intensity}:@var{antibanding}.
 +
 +This filter accepts the following named options:
 +
 +@table @option
 +@item strength
 +Determine the amount of equalization to be applied.  As the strength
 +is reduced, the distribution of pixel intensities more-and-more
 +approaches that of the input frame. The value must be a float number
 +in the range [0,1] and defaults to 0.200.
 +
 +@item intensity
 +Set the maximum intensity that can generated and scale the output
 +values appropriately.  The strength should be set as desired and then
 +the intensity can be limited if needed to avoid washing-out. The value
 +must be a float number in the range [0,1] and defaults to 0.210.
 +
 +@item antibanding
 +Set the antibanding level. If enabled the filter will randomly vary
 +the luminance of output pixels by a small amount to avoid banding of
 +the histogram. Possible values are @code{none}, @code{weak} or
 +@code{strong}. It defaults to @code{none}.
 +@end table
 +
 +@section histogram
 +
 +Compute and draw a color distribution histogram for the input video.
 +
 +The computed histogram is a representation of distribution of color components
 +in an image.
 +
 +The filter accepts the following named parameters:
 +
 +@table @option
 +@item mode
 +Set histogram mode.
 +
 +It accepts the following values:
 +@table @samp
 +@item levels
 +standard histogram that display color components distribution in an image.
 +Displays color graph for each color component. Shows distribution
 +of the Y, U, V, A or G, B, R components, depending on input format,
 +in current frame. Bellow each graph is color component scale meter.
 +
 +@item color
 +chroma values in vectorscope, if brighter more such chroma values are
 +distributed in an image.
 +Displays chroma values (U/V color placement) in two dimensional graph
 +(which is called a vectorscope). It can be used to read of the hue and
 +saturation of the current frame. At a same time it is a histogram.
 +The whiter a pixel in the vectorscope, the more pixels of the input frame
 +correspond to that pixel (that is the more pixels have this chroma value).
 +The V component is displayed on the horizontal (X) axis, with the leftmost
 +side being V = 0 and the rightmost side being V = 255.
 +The U component is displayed on the vertical (Y) axis, with the top
 +representing U = 0 and the bottom representing U = 255.
 +
 +The position of a white pixel in the graph corresponds to the chroma value
 +of a pixel of the input clip. So the graph can be used to read of the
 +hue (color flavor) and the saturation (the dominance of the hue in the color).
 +As the hue of a color changes, it moves around the square. At the center of
 +the square, the saturation is zero, which means that the corresponding pixel
 +has no color. If you increase the amount of a specific color, while leaving
 +the other colors unchanged, the saturation increases, and you move towards
 +the edge of the square.
 +
 +@item color2
 +chroma values in vectorscope, similar as @code{color} but actual chroma values
 +are displayed.
 +
 +@item waveform
 +per row/column color component graph. In row mode graph in the left side represents
 +color component value 0 and right side represents value = 255. In column mode top
 +side represents color component value = 0 and bottom side represents value = 255.
 +@end table
 +Default value is @code{levels}.
 +
 +@item level_height
 +Set height of level in @code{levels}. Default value is @code{200}.
 +Allowed range is [50, 2048].
 +
 +@item scale_height
 +Set height of color scale in @code{levels}. Default value is @code{12}.
 +Allowed range is [0, 40].
 +
 +@item step
 +Set step for @code{waveform} mode. Smaller values are useful to find out how much
 +of same luminance values across input rows/columns are distributed.
 +Default value is @code{10}. Allowed range is [1, 255].
 +
 +@item waveform_mode
 +Set mode for @code{waveform}. Can be either @code{row}, or @code{column}.
 +Default is @code{row}.
 +
 +@item display_mode
 +Set display mode for @code{waveform} and @code{levels}.
 +It accepts the following values:
 +@table @samp
 +@item parade
 +Display separate graph for the color components side by side in
 +@code{row} waveform mode or one below other in @code{column} waveform mode
 +for @code{waveform} histogram mode. For @code{levels} histogram mode
 +per color component graphs are placed one bellow other.
 +
 +This display mode in @code{waveform} histogram mode makes it easy to spot
 +color casts in the highlights and shadows of an image, by comparing the
 +contours of the top and the bottom of each waveform.
 +Since whites, grays, and blacks are characterized by
 +exactly equal amounts of red, green, and blue, neutral areas of the
 +picture should display three waveforms of roughly equal width/height.
 +If not, the correction is easy to make by making adjustments to level the
 +three waveforms.
 +
 +@item overlay
 +Presents information that's identical to that in the @code{parade}, except
 +that the graphs representing color components are superimposed directly
 +over one another.
 +
 +This display mode in @code{waveform} histogram mode can make it easier to spot
 +the relative differences or similarities in overlapping areas of the color
 +components that are supposed to be identical, such as neutral whites, grays,
 +or blacks.
 +@end table
 +Default is @code{parade}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +
 +@item
 +Calculate and draw histogram:
 +@example
 +ffplay -i input -vf histogram
 +@end example
 +
 +@end itemize
 +
 +@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:
 +@var{luma_spatial}:@var{chroma_spatial}:@var{luma_tmp}:@var{chroma_tmp}
 +
 +@table @option
 +@item luma_spatial
 +a non-negative float number which specifies spatial luma strength,
 +defaults to 4.0
 +
 +@item chroma_spatial
 +a non-negative float number which specifies spatial chroma strength,
 +defaults to 3.0*@var{luma_spatial}/4.0
 +
 +@item luma_tmp
 +a float number which specifies luma temporal strength, defaults to
 +6.0*@var{luma_spatial}/4.0
 +
 +@item chroma_tmp
 +a float number which specifies chroma temporal strength, defaults to
 +@var{luma_tmp}*@var{chroma_spatial}/@var{luma_spatial}
 +@end table
 +
 +@section hue
 +
 +Modify the hue and/or the saturation of the input.
 +
 +This filter accepts the following optional named options:
 +
 +@table @option
 +@item h
 +Specify the hue angle as a number of degrees. It accepts a float
 +number or an expression, and defaults to 0.0.
 +
 +@item H
 +Specify the hue angle as a number of radians. It accepts a float
 +number or an expression, and defaults to 0.0.
 +
 +@item s
 +Specify the saturation in the [-10,10] range. It accepts a float number and
 +defaults to 1.0.
 +@end table
 +
 +The @var{h}, @var{H} and @var{s} parameters are expressions containing the
 +following constants:
 +
 +@table @option
 +@item n
 +frame count of the input frame starting from 0
 +
 +@item pts
 +presentation timestamp of the input frame expressed in time base units
 +
 +@item r
 +frame rate of the input video, NAN if the input frame rate is unknown
 +
 +@item t
 +timestamp expressed in seconds, NAN if the input timestamp is unknown
 +
 +@item tb
 +time base of the input video
 +@end table
 +
 +The options can also be set using the syntax: @var{hue}:@var{saturation}
 +
 +In this case @var{hue} is expressed in degrees.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Set the hue to 90 degrees and the saturation to 1.0:
 +@example
 +hue=h=90:s=1
 +@end example
 +
 +@item
 +Same command but expressing the hue in radians:
 +@example
 +hue=H=PI/2:s=1
 +@end example
 +
 +@item
 +Same command without named options, hue must be expressed in degrees:
 +@example
 +hue=90:1
 +@end example
 +
 +@item
 +Note that "h:s" syntax does not support expressions for the values of
 +h and s, so the following example will issue an error:
 +@example
 +hue=PI/2:1
 +@end example
 +
 +@item
 +Rotate hue and make the saturation swing between 0
 +and 2 over a period of 1 second:
 +@example
 +hue="H=2*PI*t: s=sin(2*PI*t)+1"
 +@end example
 +
 +@item
 +Apply a 3 seconds saturation fade-in effect starting at 0:
 +@example
 +hue="s=min(t/3\,1)"
 +@end example
 +
 +The general fade-in expression can be written as:
 +@example
 +hue="s=min(0\, max((t-START)/DURATION\, 1))"
 +@end example
 +
 +@item
 +Apply a 3 seconds saturation fade-out effect starting at 5 seconds:
 +@example
 +hue="s=max(0\, min(1\, (8-t)/3))"
 +@end example
 +
 +The general fade-out expression can be written as:
 +@example
 +hue="s=max(0\, min(1\, (START+DURATION-t)/DURATION))"
 +@end example
 +
 +@end itemize
 +
 +@subsection Commands
 +
 +This filter supports the following command:
 +@table @option
 +@item reinit
 +Modify the hue and/or the saturation of the input video.
 +The command accepts the same named options and syntax than when calling the
 +filter from the command-line.
 +
 +If a parameter is omitted, it is kept at its current value.
 +@end table
 +
 +@section idet
 +
 +Detect video interlacing type.
 +
 +This filter tries to detect if the input is interlaced or progressive,
 +top or bottom field first.
 +
 +@section il
 +
 +Deinterleave or interleave fields.
 +
 +This filter allows to process interlaced images fields without
 +deinterlacing them. Deinterleaving splits the input frame into 2
 +fields (so called half pictures). Odd lines are moved to the top
 +half of the output image, even lines to the bottom half.
 +You can process (filter) them independently and then re-interleave them.
 +
 +It 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
 +@item luma_mode, l
 +@item chroma_mode, s
 +@item alpha_mode, a
 +Available values for @var{luma_mode}, @var{chroma_mode} and
 +@var{alpha_mode} are:
 +
 +@table @samp
 +@item none
 +Do nothing.
 +
 +@item deinterleave, d
 +Deinterleave fields, placing one above the other.
 +
 +@item interleave, i
 +Interleave fields. Reverse the effect of deinterleaving.
 +@end table
 +Default value is @code{none}.
 +
 +@item luma_swap, ls
 +@item chroma_swap, cs
 +@item alpha_swap, as
 +Swap luma/chroma/alpha fields. Exchange even & odd lines. Default value is @code{0}.
 +@end table
 +
 +@section kerndeint
 +
 +Deinterlace input video by applying Donald Graft's adaptive kernel
 +deinterling. Work on interlaced parts of a video to produce
 +progressive frames.
 +
 +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 following syntax:
 +@var{thresh}:@var{map}:@var{order}:@var{sharp}:@var{twoway}.
 +
 +The description of the accepted parameters follows.
 +
 +@table @option
 +@item thresh
 +Set the threshold which affects the filter's tolerance when
 +determining if a pixel line must be processed. It must be an integer
 +in the range [0,255] and defaults to 10. A value of 0 will result in
 +applying the process on every pixels.
 +
 +@item map
 +Paint pixels exceeding the threshold value to white if set to 1.
 +Default is 0.
 +
 +@item order
 +Set the fields order. Swap fields if set to 1, leave fields alone if
 +0. Default is 0.
 +
 +@item sharp
 +Enable additional sharpening if set to 1. Default is 0.
 +
 +@item twoway
 +Enable twoway sharpening if set to 1. Default is 0.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply default values:
 +@example
 +kerndeint=thresh=10:map=0:order=0:sharp=0:twoway=0
 +@end example
 +
 +@item
 +Enable additional sharpening:
 +@example
 +kerndeint=sharp=1
 +@end example
 +
 +@item
 +Paint processed pixels in white:
 +@example
 +kerndeint=map=1
 +@end example
 +@end itemize
 +
 +@section lut, lutrgb, lutyuv
 +
 +Compute a look-up table for binding each pixel component input value
 +to an output value, and apply it to input video.
 +
 +@var{lutyuv} applies a lookup table to a YUV input video, @var{lutrgb}
 +to an RGB input video.
 +
 +These filters accept in input a ":"-separated list of options, which
 +specify the expressions used for computing the lookup table for the
 +corresponding pixel component values.
 +
 +The @var{lut} filter requires either YUV or RGB pixel formats in
 +input, and accepts the options:
 +@table @option
 +@item c0
 +set first pixel component expression
 +@item c1
 +set second pixel component expression
 +@item c2
 +set third pixel component expression
 +@item c3
 +set fourth pixel component expression, corresponds to the alpha component
 +@end table
 +
 +The exact component associated to each option depends on the format in
 +input.
 +
 +The @var{lutrgb} filter requires RGB pixel formats in input, and
 +accepts the options:
 +@table @option
 +@item r
 +set red component expression
 +@item g
 +set green component expression
 +@item b
 +set blue component expression
 +@item a
 +alpha component expression
 +@end table
 +
 +The @var{lutyuv} filter requires YUV pixel formats in input, and
 +accepts the options:
 +@table @option
 +@item y
 +set Y/luminance component expression
 +@item u
 +set U/Cb component expression
 +@item v
 +set V/Cr component expression
 +@item a
 +set alpha component expression
 +@end table
 +
 +The expressions can contain the following constants and functions:
 +
 +@table @option
 +@item w, h
 +the input width and height
 +
 +@item val
 +input value for the pixel component
 +
 +@item clipval
 +the input value clipped in the @var{minval}-@var{maxval} range
 +
 +@item maxval
 +maximum value for the pixel component
 +
 +@item minval
 +minimum value for the pixel component
 +
 +@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 clip(val)
 +the computed value in @var{val} clipped in the
 +@var{minval}-@var{maxval} range
 +
 +@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"
 +
 +@end table
 +
 +All expressions default to "val".
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Negate input video:
 +@example
 +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"
 +@end example
 +
 +The above is the same as:
 +@example
 +lutrgb="r=negval:g=negval:b=negval"
 +lutyuv="y=negval:u=negval:v=negval"
 +@end example
 +
 +@item
 +Negate luminance:
 +@example
 +lutyuv=y=negval
 +@end example
 +
 +@item
 +Remove chroma components, turns the video into a graytone image:
 +@example
 +lutyuv="u=128:v=128"
 +@end example
 +
 +@item
 +Apply a luma burning effect:
 +@example
 +lutyuv="y=2*val"
 +@end example
 +
 +@item
 +Remove green and blue components:
 +@example
 +lutrgb="g=0:b=0"
 +@end example
 +
 +@item
 +Set a constant alpha channel value on input:
 +@example
 +format=rgba,lutrgb=a="maxval-minval/2"
 +@end example
 +
 +@item
 +Correct luminance gamma by a 0.5 factor:
 +@example
 +lutyuv=y=gammaval(0.5)
 +@end example
 +@end itemize
 +
 +@section mp
 +
 +Apply an MPlayer filter to the input video.
 +
 +This filter provides a wrapper around most of the filters of
 +MPlayer/MEncoder.
 +
 +This wrapper is considered experimental. Some of the wrapped filters
 +may not work properly and we may drop support for them, as they will
 +be implemented natively into FFmpeg. Thus you should avoid
 +depending on them when writing portable scripts.
 +
 +The filters accepts the parameters:
 +@var{filter_name}[:=]@var{filter_params}
 +
 +@var{filter_name} is the name of a supported MPlayer filter,
 +@var{filter_params} is a string containing the parameters accepted by
 +the named filter.
 +
 +The list of the currently supported filters follows:
 +@table @var
 +@item detc
 +@item dint
 +@item divtc
 +@item down3dright
 +@item eq2
 +@item eq
 +@item fil
 +@item fspp
 +@item harddup
 +@item ilpack
 +@item ivtc
 +@item mcdeint
 +@item ow
 +@item perspective
 +@item phase
 +@item pp7
 +@item pullup
 +@item qp
 +@item sab
 +@item softpulldown
 +@item spp
 +@item telecine
 +@item tinterlace
 +@item uspp
 +@end table
 +
 +The parameter syntax and behavior for the listed filters are the same
 +of the corresponding MPlayer filters. For detailed instructions check
 +the "VIDEO FILTERS" section in the MPlayer manual.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Adjust gamma, brightness, contrast:
 +@example
 +mp=eq2=1.0:2:0.5
 +@end example
 +@end itemize
 +
 +See also mplayer(1), @url{http://www.mplayerhq.hu/}.
 +
 +@section negate
 +
 +Negate input video.
 +
 +This filter accepts an integer in input, if non-zero it negates the
 +alpha component (if available). The default value in input is 0.
 +
 +@section noformat
 +
 +Force libavfilter not to use any of the specified pixel formats for the
 +input to the next filter.
 +
 +The filter accepts a list of pixel format names, separated by ":",
 +for example "yuv420p:monow:rgb24".
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Force libavfilter to use a format different from @var{yuv420p} for the
 +input to the vflip filter:
 +@example
 +noformat=yuv420p,vflip
 +@end example
 +
 +@item
 +Convert the input video to any of the formats not contained in the list:
 +@example
 +noformat=yuv420p:yuv444p:yuv410p
 +@end example
 +@end itemize
 +
 +@section noise
 +
 +Add noise on video input frame.
 +
 +This filter 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
 +@item all_seed
 +@item c0_seed
 +@item c1_seed
 +@item c2_seed
 +@item c3_seed
 +Set noise seed for specific pixel component or all pixel components in case
 +of @var{all_seed}. Default value is @code{123457}.
 +
 +@item all_strength, alls
 +@item c0_strength, c0s
 +@item c1_strength, c1s
 +@item c2_strength, c2s
 +@item c3_strength, c3s
 +Set noise strength for specific pixel component or all pixel components in case
 +@var{all_strength}. Default value is @code{0}. Allowed range is [0, 100].
 +
 +@item all_flags, allf
 +@item c0_flags, c0f
 +@item c1_flags, c1f
 +@item c2_flags, c2f
 +@item c3_flags, c3f
 +Set pixel component flags or set flags for all components if @var{all_flags}.
 +Available values for component flags are:
 +@table @samp
 +@item a
 +averaged temporal noise (smoother)
 +@item p
 +mix random noise with a (semi)regular pattern
 +@item q
 +higher quality (slightly better looking, slightly slower)
 +@item t
 +temporal noise (noise pattern changes between frames)
 +@item u
 +uniform noise (gaussian otherwise)
 +@end table
 +@end table
 +
 +@subsection Examples
 +
 +Add temporal and uniform noise to input video:
 +@example
 +noise=alls=20:allf=t+u
 +@end example
 +
 +@section null
 +
 +Pass the video source unchanged to the output.
 +
 +@section ocv
 +
 +Apply video transform using libopencv.
 +
 +To enable this filter install libopencv library and headers and
 +configure FFmpeg with @code{--enable-libopencv}.
 +
 +The filter takes the parameters: @var{filter_name}@{:=@}@var{filter_params}.
 +
 +@var{filter_name} is the name of the libopencv filter to apply.
 +
 +@var{filter_params} specifies the parameters to pass to the libopencv
 +filter. If not specified the default values are assumed.
 +
 +Refer to the official libopencv documentation for more precise
 +information:
 +@url{http://opencv.willowgarage.com/documentation/c/image_filtering.html}
 +
 +Follows the list of supported libopencv filters.
 +
 +@anchor{dilate}
 +@subsection dilate
 +
 +Dilate an image by using a specific structuring element.
 +This filter corresponds to the libopencv function @code{cvDilate}.
 +
 +It accepts the parameters: @var{struct_el}:@var{nb_iterations}.
 +
 +@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}
 +
 +@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 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.
 +
 +The default value for @var{struct_el} is "3x3+0x0/rect".
 +
 +@var{nb_iterations} specifies the number of times the transform is
 +applied to the image, and defaults to 1.
 +
 +Follow some example:
 +@example
 +# use the default values
 +ocv=dilate
 +
 +# dilate using a structuring element with a 5x5 cross, iterate two times
 +ocv=dilate=5x5+2x2/cross:2
 +
 +# read the shape from the file diamond.shape, iterate two times
 +# the file diamond.shape may contain a pattern of characters like this:
 +#   *
 +#  ***
 +# *****
 +#  ***
 +#   *
 +# the specified cols and rows are ignored (but not the anchor point coordinates)
 +ocv=0x0+2x2/custom=diamond.shape:2
 +@end example
 +
 +@subsection erode
 +
 +Erode an image by using a specific structuring element.
 +This filter corresponds to the libopencv function @code{cvErode}.
 +
 +The filter accepts the parameters: @var{struct_el}:@var{nb_iterations},
 +with the same syntax and semantics as the @ref{dilate} filter.
 +
 +@subsection smooth
 +
 +Smooth the input video.
 +
 +The filter takes the following parameters:
 +@var{type}:@var{param1}:@var{param2}:@var{param3}:@var{param4}.
 +
 +@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".
 +
 +@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.
 +
 +The default value for @var{param1} is 3, the default value for the
 +other parameters is 0.
 +
 +These parameters correspond to the parameters assigned to the
 +libopencv function @code{cvSmooth}.
 +
 +@anchor{overlay}
 +@section overlay
 +
 +Overlay one video on top of another.
 +
 +It takes two inputs and one output, the first input is the "main"
 +video on which the second input is overlayed.
 +
 +This filter accepts a list of @var{key}=@var{value} pairs as argument,
 +separated by ":". If the key of the first options is omitted, the
 +arguments are interpreted according to the syntax @var{x}:@var{y}.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item x, y
 +Set the expression for the x and y coordinates of the overlayed video
 +on the main video. Default value is 0.
 +
 +The @var{x} and @var{y} expressions can contain the following
 +parameters:
 +@table @option
 +@item main_w, main_h
 +main input width and height
 +
 +@item W, H
 +same as @var{main_w} and @var{main_h}
 +
 +@item overlay_w, overlay_h
 +overlay input width and height
 +
 +@item w, h
 +same as @var{overlay_w} and @var{overlay_h}
 +@end table
 +
 +@item format
 +Set the format for the output video.
 +
 +It accepts the following values:
 +@table @samp
 +@item yuv420
 +force YUV420 output
 +
 +@item yuv444
 +force YUV444 output
 +
 +@item rgb
 +force RGB output
 +@end table
 +
 +Default value is @samp{yuv420}.
 +
 +@item rgb @emph{(deprecated)}
 +If set to 1, force the filter to accept inputs in the RGB
 +color space. Default value is 0. This option is deprecated, use
 +@option{format} instead.
 +
 +@item shortest
 +If set to 1, force the output to terminate when the shortest input
 +terminates. Default value is 0.
 +@end table
 +
 +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.
 +
 +You can chain together more overlays but you should test the
 +efficiency of such approach.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Draw the overlay at 10 pixels from the bottom right corner of the main
 +video:
 +@example
 +overlay=main_w-overlay_w-10:main_h-overlay_h-10
 +@end example
 +
 +Using named options the example above becomes:
 +@example
 +overlay=x=main_w-overlay_w-10:y=main_h-overlay_h-10
 +@end example
 +
 +@item
 +Insert a transparent PNG logo in the bottom left corner of the input,
 +using the @command{ffmpeg} tool with the @code{-filter_complex} option:
 +@example
 +ffmpeg -i input -i logo -filter_complex 'overlay=10:main_h-overlay_h-10' output
 +@end example
 +
 +@item
 +Insert 2 different transparent PNG logos (second logo on bottom
 +right corner) using the @command{ffmpeg} tool:
 +@example
 +ffmpeg -i input -i logo1 -i logo2 -filter_complex 'overlay=10:H-h-10,overlay=W-w-10:H-h-10' output
 +@end example
 +
 +@item
 +Add a transparent color layer on top of the main video, WxH specifies
 +the size of the main input to the overlay filter:
 +@example
 +color=red@@.3:WxH [over]; [in][over] overlay [out]
 +@end example
 +
 +@item
 +Play an original video and a filtered version (here with the deshake
 +filter) side by side using the @command{ffplay} tool:
 +@example
 +ffplay input.avi -vf 'split[a][b]; [a]pad=iw*2:ih[src]; [b]deshake[filt]; [src][filt]overlay=w'
 +@end example
 +
 +The above command is the same as:
 +@example
 +ffplay input.avi -vf 'split[b], pad=iw*2[src], [b]deshake, [src]overlay=w'
 +@end example
 +
 +@item
 +Compose output by putting two input videos side to side:
 +@example
 +ffmpeg -i left.avi -i right.avi -filter_complex "
 +nullsrc=size=200x100 [background];
 +[0:v] setpts=PTS-STARTPTS, scale=100x100 [left];
 +[1:v] setpts=PTS-STARTPTS, scale=100x100 [right];
 +[background][left]       overlay=shortest=1       [background+left];
 +[background+left][right] overlay=shortest=1:x=100 [left+right]
 +"
 +@end example
 +
 +@item
 +Chain several overlays in cascade:
 +@example
 +nullsrc=s=200x200 [bg];
 +testsrc=s=100x100, split=4 [in0][in1][in2][in3];
 +[in0] lutrgb=r=0, [bg]   overlay=0:0     [mid0];
 +[in1] lutrgb=g=0, [mid0] overlay=100:0   [mid1];
 +[in2] lutrgb=b=0, [mid1] overlay=0:100   [mid2];
 +[in3] null,       [mid2] overlay=100:100 [out0]
 +@end example
 +
 +@end itemize
 +
 +@section pad
 +
 +Add paddings to the input image, and place the original input at the
 +given coordinates @var{x}, @var{y}.
 +
 +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{width}:@var{height}:@var{x}:@var{y}:@var{color}.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item width, w
 +@item height, h
 +Specify an expression for 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.
 +
 +The @var{width} expression can reference the value set by the
 +@var{height} expression, and vice versa.
 +
 +The default value of @var{width} and @var{height} is 0.
 +
 +@item x
 +@item y
 +Specify an expression for the offsets where to place the input image
 +in the padded area with respect to the top/left border of the output
 +image.
 +
 +The @var{x} expression can reference the value set by the @var{y}
 +expression, and vice versa.
 +
 +The default value of @var{x} and @var{y} is 0.
 +
 +@item color
 +Specify the color of the padded area, it can be the name of a color
 +(case insensitive match) or a 0xRRGGBB[AA] sequence.
 +
 +The default value of @var{color} is "black".
 +@end table
 +
 +The value for the @var{width}, @var{height}, @var{x}, and @var{y}
 +options are expressions containing the following constants:
 +
 +@table @option
 +@item in_w, in_h
 +the input video width and height
 +
 +@item iw, ih
 +same as @var{in_w} and @var{in_h}
 +
 +@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 ow, oh
 +same as @var{out_w} and @var{out_h}
 +
 +@item x, y
 +x and y offsets as specified by the @var{x} and @var{y}
 +expressions, or NAN if not yet specified
 +
 +@item a
 +same as @var{iw} / @var{ih}
 +
 +@item sar
 +input sample aspect ratio
 +
 +@item dar
 +input display aspect ratio, it is the same as (@var{iw} / @var{ih}) * @var{sar}
 +
 +@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.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +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:
 +@example
 +pad=640:480:0:40:violet
 +@end example
 +
 +The example above is equivalent to the following command:
 +@example
 +pad=width=640:height=480:x=0:y=40:color=violet
 +@end example
 +
 +@item
 +Pad the input to get an output with dimensions increased by 3/2,
 +and put the input video at the center of the padded area:
 +@example
 +pad="3/2*iw:3/2*ih:(ow-iw)/2:(oh-ih)/2"
 +@end example
 +
 +@item
 +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:
 +@example
 +pad="max(iw\,ih):ow:(ow-iw)/2:(oh-ih)/2"
 +@end example
 +
 +@item
 +Pad the input to get a final w/h ratio of 16:9:
 +@example
 +pad="ih*16/9:ih:(ow-iw)/2:(oh-ih)/2"
 +@end example
 +
 +@item
 +In case of anamorphic video, in order to set the output display aspect
 +correctly, it is necessary to use @var{sar} in the expression,
 +according to the relation:
 +@example
 +(ih * X / ih) * sar = output_dar
 +X = output_dar / sar
 +@end example
 +
 +Thus the previous example needs to be modified to:
 +@example
 +pad="ih*16/9/sar:ih:(ow-iw)/2:(oh-ih)/2"
 +@end example
 +
 +@item
 +Double output size and put the input video in the bottom-right
 +corner of the output padded area:
 +@example
 +pad="2*iw:2*ih:ow-iw:oh-ih"
 +@end example
 +@end itemize
 +
 +@section pixdesctest
 +
 +Pixel format descriptor test filter, mainly useful for internal
 +testing. The output video should be equal to the input video.
 +
 +For example:
 +@example
 +format=monow, pixdesctest
 +@end example
 +
 +can be used to test the monowhite pixel format descriptor definition.
 +
 +@section pp
 +
 +Enable the specified chain of postprocessing subfilters using libpostproc. This
 +library should be automatically selected with a GPL build (@code{--enable-gpl}).
 +Subfilters must be separated by '/' and can be disabled by prepending a '-'.
 +Each subfilter and some options have a short and a long name that can be used
 +interchangeably, i.e. dr/dering are the same.
 +
 +All subfilters share common options to determine their scope:
 +
 +@table @option
 +@item a/autoq
 +Honor the quality commands for this subfilter.
 +
 +@item c/chrom
 +Do chrominance filtering, too (default).
 +
 +@item y/nochrom
 +Do luminance filtering only (no chrominance).
 +
 +@item n/noluma
 +Do chrominance filtering only (no luminance).
 +@end table
 +
 +These options can be appended after the subfilter name, separated by a ':'.
 +
 +Available subfilters are:
 +
 +@table @option
 +@item hb/hdeblock[:difference[:flatness]]
 +Horizontal deblocking filter
 +@table @option
 +@item difference
 +Difference factor where higher values mean more deblocking (default: @code{32}).
 +@item flatness
 +Flatness threshold where lower values mean more deblocking (default: @code{39}).
 +@end table
 +
 +@item vb/vdeblock[:difference[:flatness]]
 +Vertical deblocking filter
 +@table @option
 +@item difference
 +Difference factor where higher values mean more deblocking (default: @code{32}).
 +@item flatness
 +Flatness threshold where lower values mean more deblocking (default: @code{39}).
 +@end table
 +
 +@item ha/hadeblock[:difference[:flatness]]
 +Accurate horizontal deblocking filter
 +@table @option
 +@item difference
 +Difference factor where higher values mean more deblocking (default: @code{32}).
 +@item flatness
 +Flatness threshold where lower values mean more deblocking (default: @code{39}).
 +@end table
 +
 +@item va/vadeblock[:difference[:flatness]]
 +Accurate vertical deblocking filter
 +@table @option
 +@item difference
 +Difference factor where higher values mean more deblocking (default: @code{32}).
 +@item flatness
 +Flatness threshold where lower values mean more deblocking (default: @code{39}).
 +@end table
 +@end table
 +
 +The horizontal and vertical deblocking filters share the difference and
 +flatness values so you cannot set different horizontal and vertical
 +thresholds.
 +
 +@table @option
 +@item h1/x1hdeblock
 +Experimental horizontal deblocking filter
 +
 +@item v1/x1vdeblock
 +Experimental vertical deblocking filter
 +
 +@item dr/dering
 +Deringing filter
 +
 +@item tn/tmpnoise[:threshold1[:threshold2[:threshold3]]], temporal noise reducer
 +@table @option
 +@item threshold1
 +larger -> stronger filtering
 +@item threshold2
 +larger -> stronger filtering
 +@item threshold3
 +larger -> stronger filtering
 +@end table
 +
 +@item al/autolevels[:f/fullyrange], automatic brightness / contrast correction
 +@table @option
 +@item f/fullyrange
 +Stretch luminance to @code{0-255}.
 +@end table
 +
 +@item lb/linblenddeint
 +Linear blend deinterlacing filter that deinterlaces the given block by
 +filtering all lines with a @code{(1 2 1)} filter.
 +
 +@item li/linipoldeint
 +Linear interpolating deinterlacing filter that deinterlaces the given block by
 +linearly interpolating every second line.
 +
 +@item ci/cubicipoldeint
 +Cubic interpolating deinterlacing filter deinterlaces the given block by
 +cubically interpolating every second line.
 +
 +@item md/mediandeint
 +Median deinterlacing filter that deinterlaces the given block by applying a
 +median filter to every second line.
 +
 +@item fd/ffmpegdeint
 +FFmpeg deinterlacing filter that deinterlaces the given block by filtering every
 +second line with a @code{(-1 4 2 4 -1)} filter.
 +
 +@item l5/lowpass5
 +Vertically applied FIR lowpass deinterlacing filter that deinterlaces the given
 +block by filtering all lines with a @code{(-1 2 6 2 -1)} filter.
 +
 +@item fq/forceQuant[:quantizer]
 +Overrides the quantizer table from the input with the constant quantizer you
 +specify.
 +@table @option
 +@item quantizer
 +Quantizer to use
 +@end table
 +
 +@item de/default
 +Default pp filter combination (@code{hb:a,vb:a,dr:a})
 +
 +@item fa/fast
 +Fast pp filter combination (@code{h1:a,v1:a,dr:a})
 +
 +@item ac
 +High quality pp filter combination (@code{ha:a:128:7,va:a,dr:a})
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply horizontal and vertical deblocking, deringing and automatic
 +brightness/contrast:
 +@example
 +pp=hb/vb/dr/al
 +@end example
 +
 +@item
 +Apply default filters without brightness/contrast correction:
 +@example
 +pp=de/-al
 +@end example
 +
 +@item
 +Apply default filters and temporal denoiser:
 +@example
 +pp=default/tmpnoise:1:2:3
 +@end example
 +
 +@item
 +Apply deblocking on luminance only, and switch vertical deblocking on or off
 +automatically depending on available CPU time:
 +@example
 +pp=hb:y/vb:a
 +@end example
 +@end itemize
 +
 +@section removelogo
 +
 +Suppress a TV station logo, using an image file to determine which
 +pixels comprise the logo. It works by filling in the pixels that
 +comprise the logo with neighboring pixels.
 +
 +This filter requires one argument which specifies the filter bitmap
 +file, which can be any image format supported by libavformat. The
 +width and height of the image file must match those of the video
 +stream being processed.
 +
 +Pixels in the provided bitmap image with a value of zero are not
 +considered part of the logo, non-zero pixels are considered part of
 +the logo. If you use white (255) for the logo and black (0) for the
 +rest, you will be safe. For making the filter bitmap, it is
 +recommended to take a screen capture of a black frame with the logo
 +visible, and then using a threshold filter followed by the erode
 +filter once or twice.
 +
 +If needed, little splotches can be fixed manually. Remember that if
 +logo pixels are not covered, the filter quality will be much
 +reduced. Marking too many pixels as part of the logo does not hurt as
 +much, but it will increase the amount of blurring needed to cover over
 +the image and will destroy more information than necessary, and extra
 +pixels will slow things down on a large logo.
 +
 +@section scale
 +
 +Scale (resize) the input video, using the libswscale library.
 +
 +The scale filter forces the output display aspect ratio to be the same
 +of the input, by changing the output sample aspect ratio.
 +
 +This filter accepts a list of named options in the form of
 +@var{key}=@var{value} pairs separated by ":". If the key for the first
 +two options is not specified, the assumed keys for the first two
 +values are @code{w} and @code{h}. If the first option has no key and
 +can be interpreted like a video size specification, it will be used
 +to set the video size.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item width, w
 +Set the video width expression, default value is @code{iw}. See below
 +for the list of accepted constants.
 +
 +@item height, h
 +Set the video heiht expression, default value is @code{ih}.
 +See below for the list of accepted constants.
 +
 +@item interl
 +Set the interlacing. It accepts the following values:
 +
 +@table @option
 +@item 1
 +force interlaced aware scaling
 +
 +@item 0
 +do not apply interlaced scaling
 +
 +@item -1
 +select interlaced aware scaling depending on whether the source frames
 +are flagged as interlaced or not
 +@end table
 +
 +Default value is @code{0}.
 +
 +@item flags
 +Set libswscale scaling flags. If not explictly specified the filter
 +applies a bilinear scaling algorithm.
 +
 +@item size, s
 +Set the video size, the value must be a valid abbreviation or in the
 +form @var{width}x@var{height}.
 +@end table
 +
 +The values of the @var{w} and @var{h} options are expressions
 +containing the following constants:
 +
 +@table @option
 +@item in_w, in_h
 +the input width and height
 +
 +@item iw, ih
 +same as @var{in_w} and @var{in_h}
 +
 +@item out_w, out_h
 +the output (cropped) width and height
 +
 +@item ow, oh
 +same as @var{out_w} and @var{out_h}
 +
 +@item a
 +same as @var{iw} / @var{ih}
  
 -@item t
 -timestamp expressed in seconds, NAN if the input timestamp is unknown
 +@item sar
 +input sample aspect ratio
 +
 +@item dar
 +input display aspect ratio, it is the same as (@var{iw} / @var{ih}) * @var{sar}
  
 +@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.
  @end table
  
 -The @var{out_w} and @var{out_h} parameters specify the expressions for
 -the width and height of the output (cropped) video. They are
 -evaluated just at the configuration of the filter.
 +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.
  
 -The default value of @var{out_w} is "in_w", and the default value of
 -@var{out_h} is "in_h".
 +If the value for @var{width} or @var{height} is 0, the respective input
 +size is used for the output.
  
 -The expression for @var{out_w} may depend on the value of @var{out_h},
 -and the expression for @var{out_h} may depend on @var{out_w}, but they
 -cannot depend on @var{x} and @var{y}, as @var{x} and @var{y} are
 -evaluated after @var{out_w} and @var{out_h}.
 +If the value for @var{width} or @var{height} is -1, the scale filter will
 +use, for the respective output size, a value that maintains the aspect
 +ratio of the input image.
  
 -The @var{x} and @var{y} parameters specify the expressions for the
 -position of the top-left corner of the output (non-cropped) area. They
 -are evaluated for each frame. If the evaluated value is not valid, it
 -is approximated to the nearest valid value.
 +@subsection Examples
  
 -The default value of @var{x} is "(in_w-out_w)/2", and the default
 -value for @var{y} is "(in_h-out_h)/2", which set the cropped area at
 -the center of the input image.
 +@itemize
 +@item
 +Scale the input video to a size of 200x100:
 +@example
 +scale=200:100
 +@end example
  
 -The expression for @var{x} may depend on @var{y}, and the expression
 -for @var{y} may depend on @var{x}.
 +This is equivalent to:
 +@example
 +scale=w=200:h=100
 +@end example
  
 -Follow some examples:
 +or:
  @example
 -# crop the central input area with size 100x100
 -crop=100:100
 +scale=200x100
 +@end example
  
 -# crop the central input area with size 2/3 of the input video
 -"crop=2/3*in_w:2/3*in_h"
 +@item
 +Specify a size abbreviation for the output size:
 +@example
 +scale=qcif
 +@end example
  
 -# crop the input video central square
 -crop=in_h
 +which can also be written as:
 +@example
 +scale=size=qcif
 +@end example
  
 -# delimit the rectangle with the top-left corner placed at position
 -# 100:100 and the right-bottom corner corresponding to the right-bottom
 -# corner of the input image.
 -crop=in_w-100:in_h-100:100:100
 +@item
 +Scale the input to 2x:
 +@example
 +scale=2*iw:2*ih
 +@end example
  
 -# crop 10 pixels from the left and right borders, and 20 pixels from
 -# the top and bottom borders
 -"crop=in_w-2*10:in_h-2*20"
 +@item
 +The above is the same as:
 +@example
 +scale=2*in_w:2*in_h
 +@end example
  
 -# keep only the bottom right quarter of the input image
 -"crop=in_w/2:in_h/2:in_w/2:in_h/2"
 +@item
 +Scale the input to 2x with forced interlaced scaling:
 +@example
 +scale=2*iw:2*ih:interl=1
 +@end example
  
 -# crop height for getting Greek harmony
 -"crop=in_w:1/PHI*in_w"
 +@item
 +Scale the input to half size:
 +@example
 +scale=iw/2:ih/2
 +@end example
  
 -# trembling effect
 -"crop=in_w/2:in_h/2:(in_w-out_w)/2+((in_w-out_w)/2)*sin(n/10):(in_h-out_h)/2 +((in_h-out_h)/2)*sin(n/7)"
 +@item
 +Increase the width, and set the height to the same size:
 +@example
 +scale=3/2*iw:ow
 +@end example
  
 -# erratic camera effect depending on timestamp
 -"crop=in_w/2:in_h/2:(in_w-out_w)/2+((in_w-out_w)/2)*sin(t*10):(in_h-out_h)/2 +((in_h-out_h)/2)*sin(t*13)"
 +@item
 +Seek for Greek harmony:
 +@example
 +scale=iw:1/PHI*iw
 +scale=ih*PHI:ih
 +@end example
  
 -# set x depending on the value of y
 -"crop=in_w/2:in_h/2:y:10+10*sin(n/10)"
 +@item
 +Increase the height, and set the width to 3/2 of the height:
 +@example
 +scale=3/2*oh:3/5*ih
  @end example
  
 -@section cropdetect
 +@item
 +Increase the size, but make the size a multiple of the chroma:
 +@example
 +scale="trunc(3/2*iw/hsub)*hsub:trunc(3/2*ih/vsub)*vsub"
 +@end example
  
 -Auto-detect crop size.
 +@item
 +Increase the width to a maximum of 500 pixels, keep the same input
 +aspect ratio:
 +@example
 +scale='min(500\, iw*3/2):-1'
 +@end example
 +@end itemize
  
 -Calculate necessary cropping parameters and prints the recommended
 -parameters through the logging system. The detected dimensions
 -correspond to the non-black area of the input video.
 +@section setdar, setsar
  
 -It accepts the syntax:
 +The @code{setdar} filter sets the Display Aspect Ratio for the filter
 +output video.
 +
 +This is done by changing the specified Sample (aka Pixel) Aspect
 +Ratio, according to the following equation:
  @example
 -cropdetect[=@var{limit}[:@var{round}[:@var{reset}]]]
 +@var{DAR} = @var{HORIZONTAL_RESOLUTION} / @var{VERTICAL_RESOLUTION} * @var{SAR}
 +@end example
 +
 +Keep in mind that the @code{setdar} filter does not modify the pixel
 +dimensions of the video frame. Also the display aspect ratio set by
 +this filter may be changed by later filters in the filterchain,
 +e.g. in case of scaling or if another "setdar" or a "setsar" filter is
 +applied.
 +
 +The @code{setsar} filter sets the Sample (aka Pixel) Aspect Ratio for
 +the filter output video.
 +
 +Note that as a consequence of the application of this filter, the
 +output display aspect ratio will change according to the equation
 +above.
 +
 +Keep in mind that the sample aspect ratio set by the @code{setsar}
 +filter may be changed by later filters in the filterchain, e.g. if
 +another "setsar" or a "setdar" filter is applied.
 +
 +The @code{setdar} and @code{setsar} filters accept a string in the
 +form @var{num}:@var{den} expressing an aspect ratio, or the following
 +named options, expressed as a sequence of @var{key}=@var{value} pairs,
 +separated by ":".
 +
 +@table @option
 +@item max
 +Set the maximum integer value to use for expressing numerator and
 +denominator when reducing the expressed aspect ratio to a rational.
 +Default value is @code{100}.
 +
 +@item r, ratio:
 +Set the aspect ratio used by the filter.
 +
 +The parameter can be a floating point number string, an expression, or
 +a string of the form @var{num}:@var{den}, where @var{num} and
 +@var{den} are the numerator and denominator of the aspect ratio. If
 +the parameter is not specified, it is assumed the value "0".
 +In case the form "@var{num}:@var{den}" the @code{:} character should
 +be escaped.
 +@end table
 +
 +If the keys are omitted in the named options list, the specifed values
 +are assumed to be @var{ratio} and @var{max} in that order.
 +
 +For example to change the display aspect ratio to 16:9, specify:
 +@example
 +setdar='16:9'
 +@end example
 +
 +The example above is equivalent to:
 +@example
 +setdar=1.77777
 +@end example
 +
 +To change the sample aspect ratio to 10:11, specify:
 +@example
 +setsar='10:11'
 +@end example
 +
 +To set a display aspect ratio of 16:9, and specify a maximum integer value of
 +1000 in the aspect ratio reduction, use the command:
 +@example
 +setdar=ratio='16:9':max=1000
  @end example
  
 -@table @option
 +@section setfield
 +
 +Force field for the output video frame.
 +
 +The @code{setfield} filter marks the interlace type field for the
 +output frames. It does not change the input frame, but only sets the
 +corresponding property, which affects how the frame is treated by
 +following filters (e.g. @code{fieldorder} or @code{yadif}).
 +
 +This filter accepts a single option @option{mode}, which can be
 +specified either by setting @code{mode=VALUE} or setting the value
 +alone. Available values are:
 +
 +@table @samp
 +@item auto
 +Keep the same field property.
 +
 +@item bff
 +Mark the frame as bottom-field-first.
 +
 +@item tff
 +Mark the frame as top-field-first.
 +
 +@item prog
 +Mark the frame as progressive.
 +@end table
 +
 +@section showinfo
 +
 +Show a line containing various information for each input video frame.
 +The input video is not modified.
 +
 +The shown line contains a sequence of key/value pairs of the form
 +@var{key}:@var{value}.
 +
 +A description of each shown parameter follows:
 +
 +@table @option
 +@item n
 +sequential number of the input frame, starting from 0
 +
 +@item pts
 +Presentation TimeStamp of the input frame, expressed as a number of
 +time base units. The time base unit depends on the filter input pad.
 +
 +@item pts_time
 +Presentation TimeStamp of the input frame, expressed as a number of
 +seconds
 +
 +@item pos
 +position of the frame in the input stream, -1 if this information in
 +unavailable and/or meaningless (for example in case of synthetic video)
  
 -@item limit
 -Threshold, which can be optionally specified from nothing (0) to
 -everything (255), defaults to 24.
 +@item fmt
 +pixel format name
  
 -@item round
 -Value which the width/height should be divisible by, defaults to
 -16. The offset is automatically adjusted to center the video. Use 2 to
 -get only even dimensions (needed for 4:2:2 video). 16 is best when
 -encoding to most video codecs.
 +@item sar
 +sample aspect ratio of the input frame, expressed in the form
 +@var{num}/@var{den}
  
 -@item reset
 -Counter that determines after how many frames cropdetect will reset
 -the previously detected largest video area and start over to detect
 -the current optimal crop area. Defaults to 0.
 +@item s
 +size of the input frame, expressed in the form
 +@var{width}x@var{height}
  
 -This can be useful when channel logos distort the video area. 0
 -indicates never reset and return the largest area encountered during
 -playback.
 -@end table
 +@item i
 +interlaced mode ("P" for "progressive", "T" for top field first, "B"
 +for bottom field first)
  
 -@section delogo
 +@item iskey
 +1 if the frame is a key frame, 0 otherwise
  
 -Suppress a TV station logo by a simple interpolation of the surrounding
 -pixels. Just set a rectangle covering the logo and watch it disappear
 -(and sometimes something even uglier appear - your mileage may vary).
 +@item type
 +picture type of the input frame ("I" for an I-frame, "P" for a
 +P-frame, "B" for a B-frame, "?" for unknown type).
 +Check also the documentation of the @code{AVPictureType} enum and of
 +the @code{av_get_picture_type_char} function defined in
 +@file{libavutil/avutil.h}.
  
 -The filter accepts parameters as a string of the form
 -"@var{x}:@var{y}:@var{w}:@var{h}:@var{band}", or as a list of
 -@var{key}=@var{value} pairs, separated by ":".
 +@item checksum
 +Adler-32 checksum (printed in hexadecimal) of all the planes of the input frame
  
 -The description of the accepted parameters follows.
 +@item plane_checksum
 +Adler-32 checksum (printed in hexadecimal) of each plane of the input frame,
 +expressed in the form "[@var{c0} @var{c1} @var{c2} @var{c3}]"
 +@end table
  
 -@table @option
 +@section smartblur
  
 -@item x, y
 -Specify the top left corner coordinates of the logo. They must be
 -specified.
 +Blur the input video without impacting the outlines.
  
 -@item w, h
 -Specify the width and height of the logo to clear. They must be
 -specified.
 +The filter accepts the following parameters:
 +@var{luma_radius}:@var{luma_strength}:@var{luma_threshold}[:@var{chroma_radius}:@var{chroma_strength}:@var{chroma_threshold}]
  
 -@item band, t
 -Specify the thickness of the fuzzy edge of the rectangle (added to
 -@var{w} and @var{h}). The default value is 4.
 +Parameters prefixed by @var{luma} indicate that they work on the
 +luminance of the pixels whereas parameters prefixed by @var{chroma}
 +refer to the chrominance of the pixels.
  
 -@item show
 -When set to 1, a green rectangle is drawn on the screen to simplify
 -finding the right @var{x}, @var{y}, @var{w}, @var{h} parameters, and
 -@var{band} is set to 4. The default value is 0.
 +If the chroma parameters are not set, the luma parameters are used for
 +either the luminance and the chrominance of the pixels.
  
 -@end table
 +@var{luma_radius} or @var{chroma_radius} must be a float number in the
 +range [0.1,5.0] that specifies the variance of the gaussian filter
 +used to blur the image (slower if larger).
  
 -Some examples follow.
 +@var{luma_strength} or @var{chroma_strength} must be a float number in
 +the range [-1.0,1.0] that configures the blurring. A value included in
 +[0.0,1.0] will blur the image whereas a value included in [-1.0,0.0]
 +will sharpen the image.
  
 -@itemize
 +@var{luma_threshold} or @var{chroma_threshold} must be an integer in
 +the range [-30,30] that is used as a coefficient to determine whether
 +a pixel should be blurred or not. A value of 0 will filter all the
 +image, a value included in [0,30] will filter flat areas and a value
 +included in [-30,0] will filter edges.
  
 -@item
 -Set a rectangle covering the area with top left corner coordinates 0,0
 -and size 100x77, setting a band of size 10:
 -@example
 -delogo=0:0:100:77:10
 -@end example
 +@section stereo3d
  
 -@item
 -As the previous example, but use named options:
 -@example
 -delogo=x=0:y=0:w=100:h=77:band=10
 -@end example
 +Convert between different stereoscopic image formats.
  
 -@end itemize
 +This filter accepts the following named options, expressed as a
 +sequence of @var{key}=@var{value} pairs, separated by ":".
  
 -@section drawbox
 +@table @option
 +@item in
 +Set stereoscopic image format of input.
  
 -Draw a colored box on the input image.
 +Available values for input image formats are:
 +@table @samp
 +@item sbsl
 +side by side parallel (left eye left, right eye right)
  
 -It accepts the syntax:
 -@example
 -drawbox=@var{x}:@var{y}:@var{width}:@var{height}:@var{color}
 -@end example
 +@item sbsr
 +side by side crosseye (right eye left, left eye right)
  
 -@table @option
 +@item sbs2l
 +side by side parallel with half width resolution
 +(left eye left, right eye right)
  
 -@item x, y
 -Specify the top left corner coordinates of the box. Default to 0.
 +@item sbs2r
 +side by side crosseye with half width resolution
 +(right eye left, left eye right)
  
 -@item width, height
 -Specify the width and height of the box, if 0 they are interpreted as
 -the input width and height. Default to 0.
 +@item abl
 +above-below (left eye above, right eye below)
  
 -@item color
 -Specify the color of the box to write, it can be the name of a color
 -(case insensitive match) or a 0xRRGGBB[AA] sequence.
 -@end table
 +@item abr
 +above-below (right eye above, left eye below)
  
 -Follow some examples:
 -@example
 -# draw a black box around the edge of the input image
 -drawbox
 +@item ab2l
 +above-below with half height resolution
 +(left eye above, right eye below)
  
 -# draw a box with color red and an opacity of 50%
 -drawbox=10:20:200:60:red@@0.5"
 -@end example
 +@item ab2r
 +above-below with half height resolution
 +(right eye above, left eye below)
  
 -@section drawtext
 +Default value is @samp{sbsl}.
 +@end table
  
 -Draw text string or text from specified file on top of video using the
 -libfreetype library.
 +@item out
 +Set stereoscopic image format of output.
  
 -To enable compilation of this filter you need to configure Libav with
 -@code{--enable-libfreetype}.
 +Available values for output image formats are all the input formats as well as:
 +@table @samp
 +@item arbg
 +anaglyph red/blue gray
 +(red filter on left eye, blue filter on right eye)
  
 -The filter also recognizes strftime() sequences in the provided text
 -and expands them accordingly. Check the documentation of strftime().
 +@item argg
 +anaglyph red/green gray
 +(red filter on left eye, green filter on right eye)
  
 -The filter accepts parameters as a list of @var{key}=@var{value} pairs,
 -separated by ":".
 +@item arcg
 +anaglyph red/cyan gray
 +(red filter on left eye, cyan filter on right eye)
  
 -The description of the accepted parameters follows.
 +@item arch
 +anaglyph red/cyan half colored
 +(red filter on left eye, cyan filter on right eye)
  
 -@table @option
 +@item arcc
 +anaglyph red/cyan color
 +(red filter on left eye, cyan filter on right eye)
  
 -@item fontfile
 -The font file to be used for drawing text. Path must be included.
 -This parameter is mandatory.
 +@item arcd
 +anaglyph red/cyan color optimized with the least squares projection of dubois
 +(red filter on left eye, cyan filter on right eye)
  
 -@item text
 -The text string to be drawn. The text must be a sequence of UTF-8
 -encoded characters.
 -This parameter is mandatory if no file is specified with the parameter
 -@var{textfile}.
 +@item agmg
 +anaglyph green/magenta gray
 +(green filter on left eye, magenta filter on right eye)
  
 -@item textfile
 -A text file containing text to be drawn. The text must be a sequence
 -of UTF-8 encoded characters.
 +@item agmh
 +anaglyph green/magenta half colored
 +(green filter on left eye, magenta filter on right eye)
  
 -This parameter is mandatory if no text string is specified with the
 -parameter @var{text}.
 +@item agmc
 +anaglyph green/magenta colored
 +(green filter on left eye, magenta filter on right eye)
  
 -If both text and textfile are specified, an error is thrown.
 +@item agmd
 +anaglyph green/magenta color optimized with the least squares projection of dubois
 +(green filter on left eye, magenta filter on right eye)
  
 -@item x, y
 -The offsets where text will be drawn within the video frame.
 -Relative to the top/left border of the output image.
 -They accept expressions similar to the @ref{overlay} filter:
 -@table @option
 +@item aybg
 +anaglyph yellow/blue gray
 +(yellow filter on left eye, blue filter on right eye)
  
 -@item x, y
 -the computed values for @var{x} and @var{y}. They are evaluated for
 -each new frame.
 +@item aybh
 +anaglyph yellow/blue half colored
 +(yellow filter on left eye, blue filter on right eye)
  
 -@item main_w, main_h
 -main input width and height
 +@item aybc
 +anaglyph yellow/blue colored
 +(yellow filter on left eye, blue filter on right eye)
  
 -@item W, H
 -same as @var{main_w} and @var{main_h}
 +@item aybd
 +anaglyph yellow/blue color optimized with the least squares projection of dubois
 +(yellow filter on left eye, blue filter on right eye)
  
 -@item text_w, text_h
 -rendered text width and height
 +@item irl
 +interleaved rows (left eye has top row, right eye starts on next row)
  
 -@item w, h
 -same as @var{text_w} and @var{text_h}
 +@item irr
 +interleaved rows (right eye has top row, left eye starts on next row)
  
 -@item n
 -the number of frames processed, starting from 0
 +@item ml
 +mono output (left eye only)
  
 -@item t
 -timestamp expressed in seconds, NAN if the input timestamp is unknown
 +@item mr
 +mono output (right eye only)
 +@end table
  
 +Default value is @samp{arcd}.
  @end table
  
 -The default value of @var{x} and @var{y} is 0.
 +@anchor{subtitles}
 +@section subtitles
  
 -@item fontsize
 -The font size to be used for drawing text.
 -The default value of @var{fontsize} is 16.
 +Draw subtitles on top of input video using the libass library.
  
 -@item fontcolor
 -The color to be used for drawing fonts.
 -Either a string (e.g. "red") or in 0xRRGGBB[AA] format
 -(e.g. "0xff000033"), possibly followed by an alpha specifier.
 -The default value of @var{fontcolor} is "black".
 +To enable compilation of this filter you need to configure FFmpeg with
 +@code{--enable-libass}. This filter also requires a build with libavcodec and
 +libavformat to convert the passed subtitles file to ASS (Advanced Substation
 +Alpha) subtitles format.
  
 -@item boxcolor
 -The color to be used for drawing box around text.
 -Either a string (e.g. "yellow") or in 0xRRGGBB[AA] format
 -(e.g. "0xff00ff"), possibly followed by an alpha specifier.
 -The default value of @var{boxcolor} is "white".
 +This filter accepts the following named options, expressed as a
 +sequence of @var{key}=@var{value} pairs, separated by ":".
  
 -@item box
 -Used to draw a box around text using background color.
 -Value should be either 1 (enable) or 0 (disable).
 -The default value of @var{box} is 0.
 +@table @option
 +@item filename, f
 +Set the filename of the subtitle file to read. It must be specified.
  
 -@item shadowx, shadowy
 -The x and y offsets for the text shadow position with respect to the
 -position of the text. They can be either positive or negative
 -values. Default value for both is "0".
 +@item original_size
 +Specify the size of the original video, the video for which the ASS file
 +was composed. Due to a misdesign in ASS aspect ratio arithmetic, this is
 +necessary to correctly scale the fonts if the aspect ratio has been changed.
  
 -@item shadowcolor
 -The color to be used for drawing a shadow behind the drawn text.  It
 -can be a color name (e.g. "yellow") or a string in the 0xRRGGBB[AA]
 -form (e.g. "0xff00ff"), possibly followed by an alpha specifier.
 -The default value of @var{shadowcolor} is "black".
 +@item charenc
 +Set subtitles input character encoding. @code{subtitles} filter only. Only
 +useful if not UTF-8.
 +@end table
  
 -@item ft_load_flags
 -Flags to be used for loading the fonts.
 +If the first key is not specified, it is assumed that the first value
 +specifies the @option{filename}.
  
 -The flags map the corresponding flags supported by libfreetype, and are
 -a combination of the following values:
 -@table @var
 -@item default
 -@item no_scale
 -@item no_hinting
 -@item render
 -@item no_bitmap
 -@item vertical_layout
 -@item force_autohint
 -@item crop_bitmap
 -@item pedantic
 -@item ignore_global_advance_width
 -@item no_recurse
 -@item ignore_transform
 -@item monochrome
 -@item linear_design
 -@item no_autohint
 -@item end table
 -@end table
 +For example, to render the file @file{sub.srt} on top of the input
 +video, use the command:
 +@example
 +subtitles=sub.srt
 +@end example
  
 -Default value is "render".
 +which is equivalent to:
 +@example
 +subtitles=filename=sub.srt
 +@end example
  
 -For more information consult the documentation for the FT_LOAD_*
 -libfreetype flags.
 +@section split
  
 -@item tabsize
 -The size in number of spaces to use for rendering the tab.
 -Default value is 4.
 +Split input video into several identical outputs.
  
 -@item fix_bounds
 -If true, check and fix text coords to avoid clipping.
 -@end table
 +The filter accepts a single parameter which specifies the number of outputs. If
 +unspecified, it defaults to 2.
  
 -For example the command:
 +For example
  @example
 -drawtext="fontfile=/usr/share/fonts/truetype/freefont/FreeSerif.ttf: text='Test Text'"
 +ffmpeg -i INPUT -filter_complex split=5 OUTPUT
  @end example
 +will create 5 copies of the input video.
  
 -will draw "Test Text" with font FreeSerif, using the default values
 -for the optional parameters.
 -
 -The command:
 +For example:
  @example
 -drawtext="fontfile=/usr/share/fonts/truetype/freefont/FreeSerif.ttf: text='Test Text':\
 -          x=100: y=50: fontsize=24: fontcolor=yellow@@0.2: box=1: boxcolor=red@@0.2"
 +[in] split [splitout1][splitout2];
 +[splitout1] crop=100:100:0:0    [cropout];
 +[splitout2] pad=200:200:100:100 [padout];
  @end example
  
 -will draw 'Test Text' with font FreeSerif of size 24 at position x=100
 -and y=50 (counting from the top-left corner of the screen), text is
 -yellow with a red box around it. Both the text and the box have an
 -opacity of 20%.
 +will create two separate outputs from the same input, one cropped and
 +one padded.
  
 -Note that the double quotes are not necessary if spaces are not used
 -within the parameter list.
 +@section super2xsai
  
 -For more information about libfreetype, check:
 -@url{http://www.freetype.org/}.
 +Scale the input by 2x and smooth using the Super2xSaI (Scale and
 +Interpolate) pixel art scaling algorithm.
  
 -@section fade
 +Useful for enlarging pixel art images without reducing sharpness.
  
 -Apply fade-in/out effect to input video.
 +@section swapuv
 +Swap U & V plane.
  
 -It accepts the parameters:
 -@var{type}:@var{start_frame}:@var{nb_frames}
 +@section thumbnail
 +Select the most representative frame in a given sequence of consecutive frames.
  
 -@var{type} specifies if the effect type, can be either "in" for
 -fade-in, or "out" for a fade-out effect.
 +It accepts as argument the frames batch size to analyze (default @var{N}=100);
 +in a set of @var{N} frames, the filter will pick one of them, and then handle
 +the next batch of @var{N} frames until the end.
  
 -@var{start_frame} specifies the number of the start frame for starting
 -to apply the fade effect.
 +Since the filter keeps track of the whole frames sequence, a bigger @var{N}
 +value will result in a higher memory usage, so a high value is not recommended.
  
 -@var{nb_frames} specifies the number of frames for which the fade
 -effect has to last. At the end of the fade-in effect the output video
 -will have the same intensity as the input video, at the end of the
 -fade-out transition the output video will be completely black.
 +The following example extract one picture each 50 frames:
 +@example
 +thumbnail=50
 +@end example
  
 -A few usage examples follow, usable too as test scenarios.
 +Complete example of a thumbnail creation with @command{ffmpeg}:
  @example
 -# fade in first 30 frames of video
 -fade=in:0:30
 +ffmpeg -i in.avi -vf thumbnail,scale=300:200 -frames:v 1 out.png
 +@end example
  
 -# fade out last 45 frames of a 200-frame video
 -fade=out:155:45
 +@section tile
  
 -# fade in first 25 frames and fade out last 25 frames of a 1000-frame video
 -fade=in:0:25, fade=out:975:25
 +Tile several successive frames together.
  
 -# make first 5 frames black, then fade in from frame 5-24
 -fade=in:5:20
 -@end example
 +It accepts a list of options in the form of @var{key}=@var{value} pairs
 +separated by ":". A description of the accepted options follows.
  
 -@section fieldorder
 +@table @option
  
 -Transform the field order of the input video.
 +@item layout
 +Set the grid size (i.e. the number of lines and columns) in the form
 +"@var{w}x@var{h}".
  
 -It accepts one parameter which specifies the required field order that
 -the input interlaced video will be transformed to. The parameter can
 -assume one of the following values:
 +@item margin
 +Set the outer border margin in pixels.
  
 -@table @option
 -@item 0 or bff
 -output bottom field first
 -@item 1 or tff
 -output top field first
 -@end table
 +@item padding
 +Set the inner border thickness (i.e. the number of pixels between frames). For
 +more advanced padding options (such as having different values for the edges),
 +refer to the pad video filter.
  
 -Default value is "tff".
 +@item nb_frames
 +Set the maximum number of frames to render in the given area. It must be less
 +than or equal to @var{w}x@var{h}. The default value is @code{0}, meaning all
 +the area will be used.
  
 -Transformation is achieved by shifting the picture content up or down
 -by one line, and filling the remaining line with appropriate picture content.
 -This method is consistent with most broadcast field order converters.
 +@end table
  
 -If the input video is not flagged as being interlaced, or it is already
 -flagged as being of the required output field order then this filter does
 -not alter the incoming video.
 +Alternatively, the options can be specified as a flat string:
  
 -This filter is very useful when converting to or from PAL DV material,
 -which is bottom field first.
 +@var{layout}[:@var{nb_frames}[:@var{margin}[:@var{padding}]]]
  
 -For example:
 +For example, produce 8x8 PNG tiles of all keyframes (@option{-skip_frame
 +nokey}) in a movie:
  @example
 -./avconv -i in.vob -vf "fieldorder=bff" out.dv
 +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.
  
 -@section fifo
 +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 tinterlace
 +
 +Perform various types of temporal field interlacing.
 +
 +Frames are counted starting from 1, so the first input frame is
 +considered odd.
  
 -Buffer input images and send them when they are requested.
 +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.
  
 -This filter is mainly useful when auto-inserted by the libavfilter
 -framework.
 +A description of the accepted options follows.
  
 -The filter does not take parameters.
 +@table @option
  
 -@section format
 +@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.
  
 -Convert the input video to one of the specified pixel formats.
 -Libavfilter will try to pick one that is supported for the input to
 -the next filter.
 +Available values are:
  
 -The filter accepts a list of pixel format names, separated by ":",
 -for example "yuv420p:monow:rgb24".
 +@table @samp
 +@item merge, 0
 +Move odd frames into the upper field, even into the lower field,
 +generating a double height frame at half framerate.
 +
 +@item drop_odd, 1
 +Only output even frames, odd frames are dropped, generating a frame with
 +unchanged height at half framerate.
 +
 +@item drop_even, 2
 +Only output odd frames, even frames are dropped, generating a frame with
 +unchanged height at half framerate.
 +
 +@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 framerate.
 +
 +@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 framerate.
 +
 +@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 framerate.
 +
 +@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
  
 -Some examples follow:
 -@example
 -# convert the input video to the format "yuv420p"
 -format=yuv420p
 +Numeric values are deprecated but are accepted for backward
 +compatibility reasons.
  
 -# convert the input video to any of the formats in the list
 -format=yuv420p:yuv444p:yuv410p
 -@end example
 +Default mode is @code{merge}.
  
 -@section fps
 +@item flags
 +Specify flags influencing the filter process.
  
 -Convert the video to specified constant framerate by duplicating or dropping
 -frames as necessary.
 +Available value for @var{flags} is:
  
 -This filter accepts the following named parameters:
  @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 fps
 -Desired output framerate.
 +Vertical low-pass filtering can only be enabled for @option{mode}
 +@var{interleave_top} and @var{interleave_bottom}.
  
  @end table
 +@end table
  
 -@anchor{frei0r}
 -@section frei0r
 +@section transpose
  
 -Apply a frei0r effect to the input video.
 +Transpose rows with columns in the input video and optionally flip it.
  
 -To enable compilation of this filter you need to install the frei0r
 -header and configure Libav with --enable-frei0r.
 +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}.
  
 -The filter supports the syntax:
 +@table @option
 +@item dir
 +Specify the transposition direction. Can assume the following values:
 +
 +@table @samp
 +@item 0, 4
 +Rotate by 90 degrees counterclockwise and vertically flip (default), that is:
  @example
 -@var{filter_name}[@{:|=@}@var{param1}:@var{param2}:...:@var{paramN}]
 +L.R     L.l
 +. . ->  . .
 +l.r     R.r
  @end example
  
 -@var{filter_name} is 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 1, 5
 +Rotate by 90 degrees clockwise, that is:
 +@example
 +L.R     l.L
 +. . ->  . .
 +l.r     r.R
 +@end example
  
 -@var{param1}, @var{param2}, ... , @var{paramN} specify the parameters
 -for the frei0r effect.
 +@item 2, 6
 +Rotate by 90 degrees counterclockwise, that is:
 +@example
 +L.R     R.r
 +. . ->  . .
 +l.r     L.l
 +@end example
  
 -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.
 +@item 3, 7
 +Rotate by 90 degrees clockwise and vertically flip, that is:
 +@example
 +L.R     r.R
 +. . ->  . .
 +l.r     l.L
 +@end example
 +@end table
  
 -The number and kind of parameters depend on the loaded effect. If an
 -effect parameter is not specified the default value is set.
 +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.
  
 -Some examples follow:
 -@example
 -# apply the distort0r effect, set the first two double parameters
 -frei0r=distort0r:0.5:0.01
 +@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
  
 -# apply the colordistance effect, takes a color as first parameter
 -frei0r=colordistance:0.2/0.3/0.4
 -frei0r=colordistance:violet
 -frei0r=colordistance:0x112233
 +Default value is @code{none}.
 +@end table
  
 -# apply the perspective effect, specify the top left and top right
 -# image positions
 -frei0r=perspective:0.2/0.2:0.8/0.2
 +For example to rotate by 90 degrees clockwise and preserve portrait
 +layout:
 +@example
 +transpose=dir=1:passthrough=portrait
  @end example
  
 -For more information see:
 -@url{http://piksel.org/frei0r}
 +The command above can also be specified as:
 +@example
 +transpose=1:portrait
 +@end example
  
 -@section gradfun
 +@section unsharp
  
 -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.
 +Sharpen or blur the input video.
  
 -This filter is designed for playback only.  Do not use it prior to
 -lossy compression, because compression tends to lose the dither and
 -bring back the bands.
 +This filter accepts parameters as a list of @var{key}=@var{value} pairs,
 +separated by ":".
  
 -The filter takes two optional parameters, separated by ':':
 -@var{strength}:@var{radius}
 +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}
  
 -@var{strength} is 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 255, default value is
 -1.2, out-of-range values will be clipped to the valid range.
 +A description of the accepted options follows.
  
 -@var{radius} is 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 @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=1.2: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
 -
 -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.
 +@section yadif
  
 -It accepts the following optional parameters:
 -@var{luma_spatial}:@var{chroma_spatial}:@var{luma_tmp}:@var{chroma_tmp}
 +Deinterlace the input video ("yadif" means "yet another deinterlacing
 +filter").
  
 -@table @option
 -@item luma_spatial
 -a non-negative float number which specifies spatial luma strength,
 -defaults to 4.0
 +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}.
  
 -@item chroma_spatial
 -a non-negative float number which specifies spatial chroma strength,
 -defaults to 3.0*@var{luma_spatial}/4.0
 +The description of the accepted parameters follows.
  
 -@item luma_tmp
 -a float number which specifies luma temporal strength, defaults to
 -6.0*@var{luma_spatial}/4.0
 +@table @option
 +@item mode
 +Specify the interlacing mode to adopt. Accept one of the following
 +values:
  
 -@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 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
  
 -@section lut, lutrgb, lutyuv
 -
 -Compute a look-up table for binding each pixel component input value
 -to an output value, and apply it to input video.
 -
 -@var{lutyuv} applies a lookup table to a YUV input video, @var{lutrgb}
 -to an RGB input video.
 +Default value is @code{send_frame}.
  
 -These filters accept in input a ":"-separated list of options, which
 -specify the expressions used for computing the lookup table for the
 -corresponding pixel component values.
 +@item parity
 +Specify the picture field parity assumed for the input interlaced
 +video. Accept one of the following values:
  
 -The @var{lut} filter requires either YUV or RGB pixel formats in
 -input, and accepts the 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 0, tff
 +assume top field first
 +@item 1, bff
 +assume bottom field first
 +@item -1, auto
 +enable automatic detection
  @end table
  
 -The exact component associated to each option depends on the format in
 -input.
 +Default value is @code{auto}.
 +If interlacing is unknown or decoder does not export this information,
 +top field first will be assumed.
  
 -The @var{lutrgb} filter requires RGB pixel formats in input, and
 -accepts the options:
 -@table @option
 -@item @var{r} (red component)
 -@item @var{g} (green component)
 -@item @var{b} (blue component)
 -@item @var{a} (alpha component)
 -@end table
 +@item deint
 +Specify which frames to deinterlace. Accept one of the following
 +values:
  
 -The @var{lutyuv} filter requires YUV pixel formats in input, and
 -accepts the options:
  @table @option
 -@item @var{y} (Y/luminance component)
 -@item @var{u} (U/Cb component)
 -@item @var{v} (V/Cr component)
 -@item @var{a} (alpha component)
 +@item 0, all
 +deinterlace all frames
 +@item 1, interlaced
 +only deinterlace frames marked as interlaced
  @end table
  
 -The expressions can contain the following constants and functions:
 -
 -@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
 -
 -@item val
 -input value for the pixel component
 -
 -@item clipval
 -the input value clipped in the @var{minval}-@var{maxval} range
 +Default value is @code{all}.
 +@end table
  
 -@item maxval
 -maximum value for the pixel component
 +@c man end VIDEO FILTERS
  
 -@item minval
 -minimum value for the pixel component
 +@chapter Video Sources
 +@c man begin VIDEO SOURCES
  
 -@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"
 +Below is a description of the currently available video sources.
  
 -@item clip(val)
 -the computed value in @var{val} clipped in the
 -@var{minval}-@var{maxval} range
 +@section buffer
  
 -@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"
 +Buffer video frames, and make them available to the filter chain.
  
 -@end table
 +This source is mainly intended for a programmatic use, in particular
 +through the interface defined in @file{libavfilter/vsrc_buffer.h}.
  
 -All expressions default to "val".
 +It accepts a list of options in the form of @var{key}=@var{value} pairs
 +separated by ":". A description of the accepted options follows.
  
 -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"
 +@table @option
  
 -# the above is the same as
 -lutrgb="r=negval:g=negval:b=negval"
 -lutyuv="y=negval:u=negval:v=negval"
 +@item video_size
 +Specify the size (width and height) of the buffered video frames.
  
 -# negate luminance
 -lutyuv=negval
 +@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.
  
 -# remove chroma components, turns the video into a graytone image
 -lutyuv="u=128:v=128"
 +@item time_base
 +Specify the timebase assumed by the timestamps of the buffered frames.
  
 -# apply a luma burning effect
 -lutyuv="y=2*val"
 +@item time_base
 +Specify the frame rate expected for the video stream.
  
 -# remove green and blue components
 -lutrgb="g=0:b=0"
 +@item pixel_aspect
 +Specify the sample aspect ratio assumed by the video frames.
  
 -# set a constant alpha channel value on input
 -format=rgba,lutrgb=a="maxval-minval/2"
 +@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
  
 -# correct luminance gamma by a 0.5 factor
 -lutyuv=y=gammaval(0.5)
 +For example:
 +@example
 +buffer=size=320x240:pix_fmt=yuv410p:time_base=1/24:pixel_aspect=1/1
  @end example
  
 -@section negate
 -
 -Negate input video.
 +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
  
 -This filter accepts an integer in input, if non-zero it negates the
 -alpha component (if available). The default value in input is 0.
 +Alternatively, the options can be specified as a flat string, but this
 +syntax is deprecated:
  
 -Force libavfilter not to use any of the specified pixel formats for the
 -input to the next filter.
 +@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}]
  
 -The filter accepts a list of pixel format names, separated by ":",
 -for example "yuv420p:monow:rgb24".
 +@section cellauto
  
 -Some examples follow:
 -@example
 -# force libavfilter to use a format different from "yuv420p" for the
 -# input to the vflip filter
 -noformat=yuv420p,vflip
 +Create a pattern generated by an elementary cellular automaton.
  
 -# convert the input video to any of the formats not contained in the list
 -noformat=yuv420p:yuv444p:yuv410p
 -@end example
 +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.
  
 -@section null
 +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.
  
 -Pass the video source unchanged to the output.
 +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 ocv
 +@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.
  
 -Apply video transform using libopencv.
 +@item pattern, p
 +Read the initial cellular automaton state, i.e. the starting row, from
 +the specified string.
  
 -To enable this filter install libopencv library and headers and
 -configure Libav with --enable-libopencv.
 +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.
  
 -The filter takes the parameters: @var{filter_name}@{:=@}@var{filter_params}.
 +@item rate, r
 +Set the video rate, that is the number of frames generated per second.
 +Default is 25.
  
 -@var{filter_name} is the name of the libopencv filter to apply.
 +@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.
  
 -@var{filter_params} specifies the parameters to pass to the libopencv
 -filter. If not specified the default values are assumed.
 +This option is ignored when a file or a pattern is specified.
  
 -Refer to the official libopencv documentation for more precise
 -information:
 -@url{http://opencv.willowgarage.com/documentation/c/image_filtering.html}
 +@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.
  
 -Follows the list of supported libopencv filters.
 +@item rule
 +Set the cellular automaton rule, it is a number ranging from 0 to 255.
 +Default value is 110.
  
 -@anchor{dilate}
 -@subsection dilate
 +@item size, s
 +Set the size of the output video.
  
 -Dilate an image by using a specific structuring element.
 -This filter corresponds to the libopencv function @code{cvDilate}.
 +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.
  
 -It accepts the parameters: @var{struct_el}:@var{nb_iterations}.
 +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.
  
 -@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 a filename or a pattern string is not specified, the size value
 +defaults to "320x518" (used for a randomly generated initial state).
  
 -@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".
 +@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.
  
 -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.
 +@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.
  
 -The default value for @var{struct_el} is "3x3+0x0/rect".
 +@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
  
 -@var{nb_iterations} specifies the number of times the transform is
 -applied to the image, and defaults to 1.
 +@subsection Examples
  
 -Follow some example:
 +@itemize
 +@item
 +Read the initial state from @file{pattern}, and specify an output of
 +size 200x400.
  @example
 -# use the default values
 -ocv=dilate
 +cellauto=f=pattern:s=200x400
 +@end example
  
 -# dilate using a structuring element with a 5x5 cross, iterate two times
 -ocv=dilate=5x5+2x2/cross:2
 +@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
  
 -# 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=0x0+2x2/custom=diamond.shape:2
 +@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
  
 -@subsection erode
 +@item
 +Specify a more elaborated initial pattern:
 +@example
 +cellauto=p='@@@@ @@ @@@@':s=100x400:full=0:rule=18
 +@end example
  
 -Erode an image by using a specific structuring element.
 -This filter corresponds to the libopencv function @code{cvErode}.
 +@end itemize
  
 -The filter accepts the parameters: @var{struct_el}:@var{nb_iterations},
 -with the same syntax and semantics as the @ref{dilate} filter.
 +@section mandelbrot
  
 -@subsection smooth
 +Generate a Mandelbrot set fractal, and progressively zoom towards the
 +point specified with @var{start_x} and @var{start_y}.
  
 -Smooth the input video.
 +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.
  
 -The filter takes the following parameters:
 -@var{type}:@var{param1}:@var{param2}:@var{param3}:@var{param4}.
 +@table @option
  
 -@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".
 +@item end_pts
 +Set the terminal pts value. Default value is 400.
  
 -@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.
 +@item end_scale
 +Set the terminal scale value.
 +Must be a floating point value. Default value is 0.3.
  
 -The default value for @var{param1} is 3, the default value for the
 -other parameters is 0.
 +@item inner
 +Set the inner coloring mode, that is the algorithm used to draw the
 +Mandelbrot fractal internal region.
  
 -These parameters correspond to the parameters assigned to the
 -libopencv function @code{cvSmooth}.
 +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
  
 -@anchor{overlay}
 -@section overlay
 +Default value is @var{mincol}.
  
 -Overlay one video on top of another.
 +@item bailout
 +Set the bailout value. Default value is 10.0.
  
 -It takes two inputs and one output, the first input is the "main"
 -video on which the second input is overlayed.
 +@item maxiter
 +Set the maximum of iterations performed by the rendering
 +algorithm. Default value is 7189.
  
 -It accepts the parameters: @var{x}:@var{y}.
 +@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}.
  
 -@var{x} is the x coordinate of the overlayed video on the main video,
 -@var{y} is the y coordinate. The parameters are expressions containing
 -the following parameters:
 +@item rate, r
 +Set frame rate, expressed as number of frames per second. Default
 +value is "25".
  
 -@table @option
 -@item main_w, main_h
 -main input width and height
 +@item size, s
 +Set frame size. Default value is "640x480".
  
 -@item W, H
 -same as @var{main_w} and @var{main_h}
 +@item start_scale
 +Set the initial scale value. Default value is 3.0.
  
 -@item overlay_w, overlay_h
 -overlay input width and height
 +@item start_x
 +Set the initial x position. Must be a floating point value between
 +-100 and 100. Default value is -0.743643887037158704752191506114774.
  
 -@item w, h
 -same as @var{overlay_w} and @var{overlay_h}
 +@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
  
 -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.
 -
 -Follow some examples:
 -@example
 -# draw the overlay at 10 pixels from the bottom right
 -# corner of the main video.
 -overlay=main_w-overlay_w-10:main_h-overlay_h-10
 +@section mptestsrc
  
 -# insert a transparent PNG logo in the bottom left corner of the input
 -avconv -i input -i logo -filter_complex 'overlay=10:main_h-overlay_h-10' output
 +Generate various test patterns, as generated by the MPlayer test filter.
  
 -# insert 2 different transparent PNG logos (second logo on bottom
 -# right corner):
 -avconv -i input -i logo1 -i logo2 -filter_complex
 -'overlay=10:H-h-10,overlay=W-w-10:H-h-10' output
 +The size of the generated video is fixed, and is 256x256.
 +This source is useful in particular for testing encoding features.
  
 -# 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]
 -@end example
 +This source accepts an optional sequence of @var{key}=@var{value} pairs,
 +separated by ":". The description of the accepted options follows.
  
 -You can chain together more overlays but the efficiency of such
 -approach is yet to be tested.
 +@table @option
  
 -@section pad
 +@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".
  
 -Add paddings to the input image, and places the original input at the
 -given coordinates @var{x}, @var{y}.
 +@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()}.
  
 -It accepts the following parameters:
 -@var{width}:@var{height}:@var{x}:@var{y}:@var{color}.
 +If not specified, or the expressed duration is negative, the video is
 +supposed to be generated forever.
  
 -The parameters @var{width}, @var{height}, @var{x}, and @var{y} are
 -expressions containing the following constants:
 +@item test, t
  
 +Set the number or the name of the test to perform. Supported tests are:
  @table @option
 -@item E, PI, PHI
 -the corresponding mathematical approximated values for e
 -(euler number), pi (greek PI), phi (golden ratio)
 +@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
  
 -@item in_w, in_h
 -the input video width and height
 +Default value is "all", which will cycle through the list of all tests.
 +@end table
  
 -@item iw, ih
 -same as @var{in_w} and @var{in_h}
 +For example the following:
 +@example
 +testsrc=t=dc_luma
 +@end example
  
 -@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
 +will generate a "dc_luma" test pattern.
  
 -@item ow, oh
 -same as @var{out_w} and @var{out_h}
 +@section frei0r_src
  
 -@item x, y
 -x and y offsets as specified by the @var{x} and @var{y}
 -expressions, or NAN if not yet specified
 +Provide a frei0r source.
  
 -@item a
 -input display aspect ratio, same as @var{iw} / @var{ih}
 +To enable compilation of this filter you need to install the frei0r
 +header and configure FFmpeg with @code{--enable-frei0r}.
  
 -@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.
 -@end table
 +The source supports the syntax:
 +@example
 +@var{size}:@var{rate}:@var{src_name}[@{=|:@}@var{param1}:@var{param2}:...:@var{paramN}]
 +@end example
 +
 +@var{size} is the size of the video to generate, may be a string of the
 +form @var{width}x@var{height} or a frame size abbreviation.
 +@var{rate} is the rate of the video to generate, may be a string of
 +the form @var{num}/@var{den} or a frame rate abbreviation.
 +@var{src_name} is 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.
  
 -Follows the description of the accepted parameters.
 +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=200x200:10:partik0l=1234 [overlay]; [in][overlay] overlay
 +@end example
  
 -@table @option
 -@item width, height
 +@section life
  
 -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.
 +Generate a life pattern.
  
 -The @var{width} expression can reference the value set by the
 -@var{height} expression, and vice versa.
 +This source is based on a generalization of John Conway's life game.
  
 -The default value of @var{width} and @var{height} is 0.
 +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.
  
 -@item x, y
 +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.
  
 -Specify the offsets where to place the input image in the padded area
 -with respect to the top/left border of the output image.
 +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.
  
 -The @var{x} expression can reference the value set by the @var{y}
 -expression, and vice versa.
 +@table @option
 +@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.
  
 -The default value of @var{x} and @var{y} is 0.
 +If this option is not specified, the initial grid is generated
 +randomly.
  
 -@item color
 +@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.
  
 -Specify the color of the padded area, it can be the name of a color
 -(case insensitive match) or a 0xRRGGBB[AA] sequence.
 +@item size, s
 +Set the size of the output video.
  
 -The default value of @var{color} is "black".
 +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.
  
 -@end table
 +If a filename is not specified, the size value defaults to "320x240"
 +(used for a randomly generated initial grid).
  
 -Some examples follow:
 +@item stitch
 +If set to 1, stitch the left and right grid edges together, and the
 +top and bottom edges also. Defaults to 1.
  
 -@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=640:480:0:40:violet
 +@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.
  
 -# 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 life_color
 +Set the color of living (or new born) cells.
  
 -# 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 death_color
 +Set the color of dead cells. If @option{mold} is set, this is the first color
 +used to represent a dead cell.
  
 -# 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 mold_color
 +Set mold color, for definitely dead and moldy cells.
 +@end table
  
 -# 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"
 +@subsection Examples
 +
 +@itemize
 +@item
 +Read a grid from @file{pattern}, and center it on a grid of size
 +300x300 pixels:
 +@example
 +life=f=pattern:s=300x300
  @end example
  
 -@section pixdesctest
 +@item
 +Generate a random grid of size 200x200, with a fill ratio of 2/3:
 +@example
 +life=ratio=2/3:s=200x200
 +@end example
  
 -Pixel format descriptor test filter, mainly useful for internal
 -testing. The output video should be equal to the input video.
 +@item
 +Specify a custom rule for evolving a randomly generated grid:
 +@example
 +life=rule=S14/B34
 +@end example
  
 -For example:
 +@item
 +Full example with slow death effect (mold) using @command{ffplay}:
  @example
 -format=monow, pixdesctest
 +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
  
 -can be used to test the monowhite pixel format descriptor definition.
 +@section color, nullsrc, rgbtestsrc, smptebars, testsrc
  
 -@section scale
 +The @code{color} source provides an uniformly colored input.
  
 -Scale the input video to @var{width}:@var{height} and/or convert the image format.
 +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 parameters @var{width} and @var{height} are expressions containing
 -the following constants:
 +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 E, PI, PHI
 -the corresponding mathematical approximated values for e
 -(euler number), pi (greek PI), phi (golden ratio)
  
 -@item in_w, in_h
 -the input width and height
 +@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 iw, ih
 -same as @var{in_w} and @var{in_h}
 +@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 out_w, out_h
 -the output (cropped) width and height
 +@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 ow, oh
 -same as @var{out_w} and @var{out_h}
 +@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()}.
 +
 +If not specified, or the expressed duration is negative, the video is
 +supposed to be generated forever.
 +
 +@item decimals, n
 +Set the number of decimals to show in the timestamp, only used in the
 +@code{testsrc} source.
 +
 +The displayed timestamp value will correspond to the original
 +timestamp value multiplied by the power of 10 of the specified
 +value. Default value is 0.
 +@end table
 +
 +For example the following:
 +@example
 +testsrc=duration=5.3:size=qcif:rate=10
 +@end example
  
 -@item dar, a
 -input display aspect ratio, same as @var{iw} / @var{ih}
 +will generate a video with a duration of 5.3 seconds, with size
 +176x144 and a frame rate of 10 frames per second.
  
 -@item sar
 -input sample aspect ratio
 +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
  
 -@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.
 -@end table
 +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
  
 -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.
 +@c man end VIDEO SOURCES
  
 -If the value for @var{width} or @var{height} is 0, the respective input
 -size is used for the output.
 +@chapter Video Sinks
 +@c man begin VIDEO SINKS
  
 -If the value for @var{width} or @var{height} is -1, the scale filter will
 -use, for the respective output size, a value that maintains the aspect
 -ratio of the input image.
 +Below is a description of the currently available video sinks.
  
 -The default value of @var{width} and @var{height} is 0.
 +@section buffersink
  
 -Some examples follow:
 -@example
 -# scale the input video to a size of 200x100.
 -scale=200:100
 +Buffer video frames, and make them available to the end of the filter
 +graph.
  
 -# scale the input to 2x
 -scale=2*iw:2*ih
 -# the above is the same as
 -scale=2*in_w:2*in_h
 +This sink is mainly intended for a programmatic use, in particular
 +through the interface defined in @file{libavfilter/buffersink.h}.
  
 -# scale the input to half size
 -scale=iw/2:ih/2
 +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.
  
 -# increase the width, and set the height to the same size
 -scale=3/2*iw:ow
 +@section nullsink
  
 -# seek for Greek harmony
 -scale=iw:1/PHI*iw
 -scale=ih*PHI:ih
 +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.
  
 -# increase the height, and set the width to 3/2 of the height
 -scale=3/2*oh:3/5*ih
 +@c man end VIDEO SINKS
  
 -# 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"
 +@chapter Multimedia Filters
 +@c man begin MULTIMEDIA FILTERS
  
 -# increase the width to a maximum of 500 pixels, keep the same input aspect ratio
 -scale='min(500\, iw*3/2):-1'
 -@end example
 +Below is a description of the currently available multimedia filters.
  
 -@section select
 +@section aselect, select
  Select frames to pass in output.
  
 -It accepts in input an expression, which is evaluated for each input
 -frame. If the expression is evaluated to a non-zero value, the frame
 -is selected and passed to the output, otherwise it is discarded.
 +These filters accept a single option @option{expr} or @option{e}
 +specifying the select expression, which can be specified either by
 +specyfing @code{expr=VALUE} or specifying the expression
 +alone.
 +
 +The select expression is evaluated for each input frame. If the
 +evaluation result is a non-zero value, the frame is selected and
 +passed to the output, otherwise it is discarded.
  
  The expression can contain the following constants:
  
diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -1605,32 -1150,12 +1605,32 @@@ static int decode_audio(InputStream *is
              }
      }
  
 +    /* if the decoder provides a pts, use it instead of the last packet pts.
 +       the decoder could be delaying output by a packet or more. */
 +    if (decoded_frame->pts != AV_NOPTS_VALUE) {
 +        ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
 +        decoded_frame_tb   = avctx->time_base;
 +    } else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
 +        decoded_frame->pts = decoded_frame->pkt_pts;
 +        pkt->pts           = AV_NOPTS_VALUE;
 +        decoded_frame_tb   = ist->st->time_base;
 +    } else if (pkt->pts != AV_NOPTS_VALUE) {
 +        decoded_frame->pts = pkt->pts;
 +        pkt->pts           = AV_NOPTS_VALUE;
 +        decoded_frame_tb   = ist->st->time_base;
 +    }else {
 +        decoded_frame->pts = ist->dts;
 +        decoded_frame_tb   = AV_TIME_BASE_Q;
 +    }
      if (decoded_frame->pts != AV_NOPTS_VALUE)
 -        decoded_frame->pts = av_rescale_q(decoded_frame->pts,
 -                                          ist->st->time_base,
 -                                          (AVRational){1, ist->st->codec->sample_rate});
 +        decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
 +                                              (AVRational){1, ist->st->codec->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
 +                                              (AVRational){1, ist->st->codec->sample_rate});
      for (i = 0; i < ist->nb_filters; i++)
-         av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame,
-                                AV_BUFFERSRC_FLAG_PUSH);
+         av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
++        /* TODO re-add AV_BUFFERSRC_FLAG_PUSH */
 +
 +    decoded_frame->pts = AV_NOPTS_VALUE;
  
      return ret;
  }
@@@ -1730,18 -1231,10 +1730,18 @@@ static int decode_video(InputStream *is
              fb->buf->priv           = buf;
              fb->buf->free           = filter_release_buffer;
  
 +            av_assert0(buf->refcount>0);
              buf->refcount++;
 -            av_buffersrc_buffer(ist->filters[i]->filter, fb);
 +            av_buffersrc_add_ref(ist->filters[i]->filter, fb,
 +                                 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
 +                                 AV_BUFFERSRC_FLAG_NO_COPY |
 +                                 AV_BUFFERSRC_FLAG_PUSH);
          } else
-         if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, AV_BUFFERSRC_FLAG_PUSH)<0) {
 -            av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
++        if(av_buffersrc_add_frame_flags(ist->filters[i]->filter, decoded_frame, AV_BUFFERSRC_FLAG_PUSH)<0) {
 +            av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
 +            exit(1);
 +        }
 +
      }
  
      av_free(buffer_to_free);
@@@ -33,64 -16,27 +33,62 @@@ OBJS = allfilters.
         avfilter.o                                                       \
         avfiltergraph.o                                                  \
         buffer.o                                                         \
--       buffersink.o                                                     \
         buffersrc.o                                                      \
         drawutils.o                                                      \
         fifo.o                                                           \
         formats.o                                                        \
 +       graphdump.o                                                      \
         graphparser.o                                                    \
-        src_buffer.o                                                     \
 +       sink_buffer.o                                                    \
 +       transform.o                                                      \
         video.o                                                          \
  
 +
 +OBJS-$(CONFIG_AVCODEC)                       += avcodec.o
 +OBJS-$(CONFIG_AVFORMAT)                      += lavfutils.o
 +OBJS-$(CONFIG_SWSCALE)                       += lswsutils.o
 +
 +OBJS-$(CONFIG_ACONVERT_FILTER)               += af_aconvert.o
 +OBJS-$(CONFIG_AFADE_FILTER)                  += af_afade.o
  OBJS-$(CONFIG_AFORMAT_FILTER)                += af_aformat.o
 +OBJS-$(CONFIG_ALLPASS_FILTER)                += af_biquads.o
 +OBJS-$(CONFIG_AMERGE_FILTER)                 += af_amerge.o
  OBJS-$(CONFIG_AMIX_FILTER)                   += af_amix.o
  OBJS-$(CONFIG_ANULL_FILTER)                  += af_anull.o
 +OBJS-$(CONFIG_APAD_FILTER)                   += af_apad.o
 +OBJS-$(CONFIG_ARESAMPLE_FILTER)              += af_aresample.o
 +OBJS-$(CONFIG_ASELECT_FILTER)                += f_select.o
 +OBJS-$(CONFIG_ASENDCMD_FILTER)               += f_sendcmd.o
 +OBJS-$(CONFIG_ASETNSAMPLES_FILTER)           += af_asetnsamples.o
 +OBJS-$(CONFIG_ASETPTS_FILTER)                += f_setpts.o
 +OBJS-$(CONFIG_ASETTB_FILTER)                 += f_settb.o
  OBJS-$(CONFIG_ASHOWINFO_FILTER)              += af_ashowinfo.o
  OBJS-$(CONFIG_ASPLIT_FILTER)                 += split.o
 +OBJS-$(CONFIG_ASTREAMSYNC_FILTER)            += af_astreamsync.o
  OBJS-$(CONFIG_ASYNCTS_FILTER)                += af_asyncts.o
 +OBJS-$(CONFIG_ATEMPO_FILTER)                 += af_atempo.o
 +OBJS-$(CONFIG_BANDPASS_FILTER)               += af_biquads.o
 +OBJS-$(CONFIG_BANDREJECT_FILTER)             += af_biquads.o
 +OBJS-$(CONFIG_BASS_FILTER)                   += af_biquads.o
 +OBJS-$(CONFIG_BIQUAD_FILTER)                 += af_biquads.o
  OBJS-$(CONFIG_CHANNELMAP_FILTER)             += af_channelmap.o
  OBJS-$(CONFIG_CHANNELSPLIT_FILTER)           += af_channelsplit.o
 +OBJS-$(CONFIG_EARWAX_FILTER)                 += af_earwax.o
 +OBJS-$(CONFIG_EBUR128_FILTER)                += f_ebur128.o
 +OBJS-$(CONFIG_EQUALIZER_FILTER)              += af_biquads.o
 +OBJS-$(CONFIG_HIGHPASS_FILTER)               += af_biquads.o
  OBJS-$(CONFIG_JOIN_FILTER)                   += af_join.o
 +OBJS-$(CONFIG_LOWPASS_FILTER)                += af_biquads.o
 +OBJS-$(CONFIG_PAN_FILTER)                    += af_pan.o
  OBJS-$(CONFIG_RESAMPLE_FILTER)               += af_resample.o
 +OBJS-$(CONFIG_SILENCEDETECT_FILTER)          += af_silencedetect.o
 +OBJS-$(CONFIG_TREBLE_FILTER)                 += af_biquads.o
  OBJS-$(CONFIG_VOLUME_FILTER)                 += af_volume.o
 +OBJS-$(CONFIG_VOLUMEDETECT_FILTER)           += af_volumedetect.o
  
 +OBJS-$(CONFIG_AEVALSRC_FILTER)               += asrc_aevalsrc.o
  OBJS-$(CONFIG_ANULLSRC_FILTER)               += asrc_anullsrc.o
 +OBJS-$(CONFIG_FLITE_FILTER)                  += asrc_flite.o
  
  OBJS-$(CONFIG_ANULLSINK_FILTER)              += asink_anullsink.o
  
index e41095f,0000000..2cf12e3
mode 100644,000000..100644
--- /dev/null
@@@ -1,186 -1,0 +1,185 @@@
- static int  filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)
 +/*
 + * Copyright (c) 2010 S.N. Hemanth Meenakshisundaram <smeenaks@ucsd.edu>
 + * Copyright (c) 2011 Stefano Sabatini
 + * Copyright (c) 2011 Mina Nagy Zaki
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * sample format and channel layout conversion audio filter
 + */
 +
 +#include "libavutil/avstring.h"
 +#include "libavutil/channel_layout.h"
 +#include "libswresample/swresample.h"
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "internal.h"
 +
 +typedef struct {
 +    enum AVSampleFormat  out_sample_fmt;
 +    int64_t              out_chlayout;
 +    struct SwrContext *swr;
 +} AConvertContext;
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args0)
 +{
 +    AConvertContext *aconvert = ctx->priv;
 +    char *arg, *ptr = NULL;
 +    int ret = 0;
 +    char *args = av_strdup(args0);
 +
 +    aconvert->out_sample_fmt  = AV_SAMPLE_FMT_NONE;
 +    aconvert->out_chlayout    = 0;
 +
 +    if ((arg = av_strtok(args, ":", &ptr)) && strcmp(arg, "auto")) {
 +        if ((ret = ff_parse_sample_format(&aconvert->out_sample_fmt, arg, ctx)) < 0)
 +            goto end;
 +    }
 +    if ((arg = av_strtok(NULL, ":", &ptr)) && strcmp(arg, "auto")) {
 +        if ((ret = ff_parse_channel_layout(&aconvert->out_chlayout, arg, ctx)) < 0)
 +            goto end;
 +    }
 +
 +end:
 +    av_freep(&args);
 +    return ret;
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    AConvertContext *aconvert = ctx->priv;
 +    swr_free(&aconvert->swr);
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    AVFilterFormats *formats = NULL;
 +    AConvertContext *aconvert = ctx->priv;
 +    AVFilterLink *inlink  = ctx->inputs[0];
 +    AVFilterLink *outlink = ctx->outputs[0];
 +    AVFilterChannelLayouts *layouts;
 +
 +    ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_AUDIO),
 +                         &inlink->out_formats);
 +    if (aconvert->out_sample_fmt != AV_SAMPLE_FMT_NONE) {
 +        formats = NULL;
 +        ff_add_format(&formats, aconvert->out_sample_fmt);
 +        ff_formats_ref(formats, &outlink->in_formats);
 +    } else
 +        ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_AUDIO),
 +                             &outlink->in_formats);
 +
 +    ff_channel_layouts_ref(ff_all_channel_layouts(),
 +                         &inlink->out_channel_layouts);
 +    if (aconvert->out_chlayout != 0) {
 +        layouts = NULL;
 +        ff_add_channel_layout(&layouts, aconvert->out_chlayout);
 +        ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
 +    } else
 +        ff_channel_layouts_ref(ff_all_channel_layouts(),
 +                             &outlink->in_channel_layouts);
 +
 +    return 0;
 +}
 +
 +static int config_output(AVFilterLink *outlink)
 +{
 +    int ret;
 +    AVFilterContext *ctx = outlink->src;
 +    AVFilterLink *inlink = ctx->inputs[0];
 +    AConvertContext *aconvert = ctx->priv;
 +    char buf1[64], buf2[64];
 +
 +    /* if not specified in args, use the format and layout of the output */
 +    if (aconvert->out_sample_fmt == AV_SAMPLE_FMT_NONE)
 +        aconvert->out_sample_fmt = outlink->format;
 +    if (aconvert->out_chlayout   == 0)
 +        aconvert->out_chlayout   = outlink->channel_layout;
 +
 +    aconvert->swr = swr_alloc_set_opts(aconvert->swr,
 +                                       aconvert->out_chlayout, aconvert->out_sample_fmt, inlink->sample_rate,
 +                                       inlink->channel_layout, inlink->format,           inlink->sample_rate,
 +                                       0, ctx);
 +    if (!aconvert->swr)
 +        return AVERROR(ENOMEM);
 +    ret = swr_init(aconvert->swr);
 +    if (ret < 0)
 +        return ret;
 +
 +    av_get_channel_layout_string(buf1, sizeof(buf1),
 +                                 -1, inlink ->channel_layout);
 +    av_get_channel_layout_string(buf2, sizeof(buf2),
 +                                 -1, outlink->channel_layout);
 +    av_log(ctx, AV_LOG_VERBOSE,
 +           "fmt:%s cl:%s -> fmt:%s cl:%s\n",
 +           av_get_sample_fmt_name(inlink ->format), buf1,
 +           av_get_sample_fmt_name(outlink->format), buf2);
 +
 +    return 0;
 +}
 +
-     const int n = insamplesref->audio->nb_samples;
++static int  filter_frame(AVFilterLink *inlink, AVFrame *insamplesref)
 +{
 +    AConvertContext *aconvert = inlink->dst->priv;
-     AVFilterBufferRef *outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n);
++    const int n = insamplesref->nb_samples;
 +    AVFilterLink *const outlink = inlink->dst->outputs[0];
-     swr_convert(aconvert->swr, outsamplesref->data, n,
-                         (void *)insamplesref->data, n);
++    AVFrame *outsamplesref = ff_get_audio_buffer(outlink, n);
 +    int ret;
 +
-     avfilter_copy_buffer_ref_props(outsamplesref, insamplesref);
-     outsamplesref->audio->channels       = outlink->channels;
-     outsamplesref->audio->channel_layout = outlink->channel_layout;
++    swr_convert(aconvert->swr, outsamplesref->extended_data, n,
++                        (void *)insamplesref->extended_data, n);
 +
-     avfilter_unref_buffer(insamplesref);
++    av_frame_copy_props(outsamplesref, insamplesref);
++    outsamplesref->channels       = outlink->channels;
++    outsamplesref->channel_layout = outlink->channel_layout;
 +
 +    ret = ff_filter_frame(outlink, outsamplesref);
-         .min_perms    = AV_PERM_READ,
++    av_frame_free(&insamplesref);
 +    return ret;
 +}
 +
 +static const AVFilterPad aconvert_inputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad aconvert_outputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .config_props = config_output,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_aconvert = {
 +    .name          = "aconvert",
 +    .description   = NULL_IF_CONFIG_SMALL("Convert the input audio to sample_fmt:channel_layout."),
 +    .priv_size     = sizeof(AConvertContext),
 +    .init          = init,
 +    .uninit        = uninit,
 +    .query_formats = query_formats,
 +    .inputs        = aconvert_inputs,
 +    .outputs       = aconvert_outputs,
 +};
index 00a05e2,0000000..0e660a3
mode 100644,000000..100644
--- /dev/null
@@@ -1,307 -1,0 +1,307 @@@
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
 +/*
 + * Copyright (c) 2013 Paul B Mahol
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * fade audio filter
 + */
 +
 +#include "libavutil/opt.h"
 +#include "audio.h"
 +#include "avfilter.h"
 +#include "internal.h"
 +
 +typedef struct {
 +    const AVClass *class;
 +    int type;
 +    int curve;
 +    int nb_samples;
 +    int64_t start_sample;
 +    double duration;
 +    double start_time;
 +
 +    void (*fade_samples)(uint8_t **dst, uint8_t * const *src,
 +                         int nb_samples, int channels, int direction,
 +                         int64_t start, int range, int curve);
 +} AudioFadeContext;
 +
 +enum CurveType { TRI, QSIN, ESIN, HSIN, LOG, PAR, QUA, CUB, SQU, CBR };
 +
 +#define OFFSET(x) offsetof(AudioFadeContext, x)
 +#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
 +static const AVOption afade_options[] = {
 +    { "type",         "set the fade direction",                      OFFSET(type),         AV_OPT_TYPE_INT,    {.i64 = 0    }, 0, 1, FLAGS, "type" },
 +    { "t",            "set the fade direction",                      OFFSET(type),         AV_OPT_TYPE_INT,    {.i64 = 0    }, 0, 1, FLAGS, "type" },
 +    { "in",           NULL,                                          0,                    AV_OPT_TYPE_CONST,  {.i64 = 0    }, 0, 0, FLAGS, "type" },
 +    { "out",          NULL,                                          0,                    AV_OPT_TYPE_CONST,  {.i64 = 1    }, 0, 0, FLAGS, "type" },
 +    { "start_sample", "set expression of sample to start fading",    OFFSET(start_sample), AV_OPT_TYPE_INT64,  {.i64 = 0    }, 0, INT64_MAX, FLAGS },
 +    { "ss",           "set expression of sample to start fading",    OFFSET(start_sample), AV_OPT_TYPE_INT64,  {.i64 = 0    }, 0, INT64_MAX, FLAGS },
 +    { "nb_samples",   "set expression for fade duration in samples", OFFSET(nb_samples),   AV_OPT_TYPE_INT,    {.i64 = 44100}, 1, INT32_MAX, FLAGS },
 +    { "ns",           "set expression for fade duration in samples", OFFSET(nb_samples),   AV_OPT_TYPE_INT,    {.i64 = 44100}, 1, INT32_MAX, FLAGS },
 +    { "start_time",   "set expression of second to start fading",    OFFSET(start_time),   AV_OPT_TYPE_DOUBLE, {.dbl = 0.   }, 0, 7*24*60*60,FLAGS },
 +    { "st",           "set expression of second to start fading",    OFFSET(start_time),   AV_OPT_TYPE_DOUBLE, {.dbl = 0.   }, 0, 7*24*60*60,FLAGS },
 +    { "duration",     "set expression for fade duration in seconds", OFFSET(duration),     AV_OPT_TYPE_DOUBLE, {.dbl = 0.   }, 0, 24*60*60,  FLAGS },
 +    { "d",            "set expression for fade duration in seconds", OFFSET(duration),     AV_OPT_TYPE_DOUBLE, {.dbl = 0.   }, 0, 24*60*60,  FLAGS },
 +    { "curve",        "set expression for fade curve",               OFFSET(curve),        AV_OPT_TYPE_INT,    {.i64 = TRI  }, TRI, CBR, FLAGS, "curve" },
 +    { "c",            "set expression for fade curve",               OFFSET(curve),        AV_OPT_TYPE_INT,    {.i64 = TRI  }, TRI, CBR, FLAGS, "curve" },
 +    { "tri",          "linear slope",                                0,                    AV_OPT_TYPE_CONST,  {.i64 = TRI  }, 0, 0, FLAGS, "curve" },
 +    { "qsin",         "quarter of sine wave",                        0,                    AV_OPT_TYPE_CONST,  {.i64 = QSIN }, 0, 0, FLAGS, "curve" },
 +    { "esin",         "exponential sine wave",                       0,                    AV_OPT_TYPE_CONST,  {.i64 = ESIN }, 0, 0, FLAGS, "curve" },
 +    { "hsin",         "half of sine wave",                           0,                    AV_OPT_TYPE_CONST,  {.i64 = HSIN }, 0, 0, FLAGS, "curve" },
 +    { "log",          "logarithmic",                                 0,                    AV_OPT_TYPE_CONST,  {.i64 = LOG  }, 0, 0, FLAGS, "curve" },
 +    { "par",          "inverted parabola",                           0,                    AV_OPT_TYPE_CONST,  {.i64 = PAR  }, 0, 0, FLAGS, "curve" },
 +    { "qua",          "quadratic",                                   0,                    AV_OPT_TYPE_CONST,  {.i64 = QUA  }, 0, 0, FLAGS, "curve" },
 +    { "cub",          "cubic",                                       0,                    AV_OPT_TYPE_CONST,  {.i64 = CUB  }, 0, 0, FLAGS, "curve" },
 +    { "squ",          "square root",                                 0,                    AV_OPT_TYPE_CONST,  {.i64 = SQU  }, 0, 0, FLAGS, "curve" },
 +    { "cbr",          "cubic root",                                  0,                    AV_OPT_TYPE_CONST,  {.i64 = CBR  }, 0, 0, FLAGS, "curve" },
 +    {NULL},
 +};
 +
 +AVFILTER_DEFINE_CLASS(afade);
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    AudioFadeContext *afade = ctx->priv;
 +    int ret;
 +
 +    afade->class = &afade_class;
 +    av_opt_set_defaults(afade);
 +
 +    if ((ret = av_set_options_string(afade, args, "=", ":")) < 0)
 +        return ret;
 +
 +    if (INT64_MAX - afade->nb_samples < afade->start_sample)
 +        return AVERROR(EINVAL);
 +
 +    return 0;
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    AVFilterFormats *formats;
 +    AVFilterChannelLayouts *layouts;
 +    static const enum AVSampleFormat sample_fmts[] = {
 +        AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
 +        AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P,
 +        AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
 +        AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
 +        AV_SAMPLE_FMT_NONE
 +    };
 +
 +    layouts = ff_all_channel_layouts();
 +    if (!layouts)
 +        return AVERROR(ENOMEM);
 +    ff_set_common_channel_layouts(ctx, layouts);
 +
 +    formats = ff_make_format_list(sample_fmts);
 +    if (!formats)
 +        return AVERROR(ENOMEM);
 +    ff_set_common_formats(ctx, formats);
 +
 +    formats = ff_all_samplerates();
 +    if (!formats)
 +        return AVERROR(ENOMEM);
 +    ff_set_common_samplerates(ctx, formats);
 +
 +    return 0;
 +}
 +
 +static double fade_gain(int curve, int64_t index, int range)
 +{
 +    double gain;
 +
 +    gain = FFMAX(0.0, FFMIN(1.0, 1.0 * index / range));
 +
 +    switch (curve) {
 +    case QSIN:
 +        gain = sin(gain * M_PI / 2.0);
 +        break;
 +    case ESIN:
 +        gain = 1.0 - cos(M_PI / 4.0 * (pow(2.0*gain - 1, 3) + 1));
 +        break;
 +    case HSIN:
 +        gain = (1.0 - cos(gain * M_PI)) / 2.0;
 +        break;
 +    case LOG:
 +        gain = pow(0.1, (1 - gain) * 5.0);
 +        break;
 +    case PAR:
 +        gain = (1 - (1 - gain) * (1 - gain));
 +        break;
 +    case QUA:
 +        gain *= gain;
 +        break;
 +    case CUB:
 +        gain = gain * gain * gain;
 +        break;
 +    case SQU:
 +        gain = sqrt(gain);
 +        break;
 +    case CBR:
 +        gain = cbrt(gain);
 +        break;
 +    }
 +
 +    return gain;
 +}
 +
 +#define FADE_PLANAR(name, type)                                             \
 +static void fade_samples_## name ##p(uint8_t **dst, uint8_t * const *src,   \
 +                                     int nb_samples, int channels, int dir, \
 +                                     int64_t start, int range, int curve)   \
 +{                                                                           \
 +    int i, c;                                                               \
 +                                                                            \
 +    for (i = 0; i < nb_samples; i++) {                                      \
 +        double gain = fade_gain(curve, start + i * dir, range);             \
 +        for (c = 0; c < channels; c++) {                                    \
 +            type *d = (type *)dst[c];                                       \
 +            const type *s = (type *)src[c];                                 \
 +                                                                            \
 +            d[i] = s[i] * gain;                                             \
 +        }                                                                   \
 +    }                                                                       \
 +}
 +
 +#define FADE(name, type)                                                    \
 +static void fade_samples_## name (uint8_t **dst, uint8_t * const *src,      \
 +                                  int nb_samples, int channels, int dir,    \
 +                                  int64_t start, int range, int curve)      \
 +{                                                                           \
 +    type *d = (type *)dst[0];                                               \
 +    const type *s = (type *)src[0];                                         \
 +    int i, c, k = 0;                                                        \
 +                                                                            \
 +    for (i = 0; i < nb_samples; i++) {                                      \
 +        double gain = fade_gain(curve, start + i * dir, range);             \
 +        for (c = 0; c < channels; c++, k++)                                 \
 +            d[k] = s[k] * gain;                                             \
 +    }                                                                       \
 +}
 +
 +FADE_PLANAR(dbl, double)
 +FADE_PLANAR(flt, float)
 +FADE_PLANAR(s16, int16_t)
 +FADE_PLANAR(s32, int32_t)
 +
 +FADE(dbl, double)
 +FADE(flt, float)
 +FADE(s16, int16_t)
 +FADE(s32, int32_t)
 +
 +static int config_output(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx    = outlink->src;
 +    AudioFadeContext *afade = ctx->priv;
 +    AVFilterLink *inlink    = ctx->inputs[0];
 +
 +    switch (inlink->format) {
 +    case AV_SAMPLE_FMT_DBL:  afade->fade_samples = fade_samples_dbl;  break;
 +    case AV_SAMPLE_FMT_DBLP: afade->fade_samples = fade_samples_dblp; break;
 +    case AV_SAMPLE_FMT_FLT:  afade->fade_samples = fade_samples_flt;  break;
 +    case AV_SAMPLE_FMT_FLTP: afade->fade_samples = fade_samples_fltp; break;
 +    case AV_SAMPLE_FMT_S16:  afade->fade_samples = fade_samples_s16;  break;
 +    case AV_SAMPLE_FMT_S16P: afade->fade_samples = fade_samples_s16p; break;
 +    case AV_SAMPLE_FMT_S32:  afade->fade_samples = fade_samples_s32;  break;
 +    case AV_SAMPLE_FMT_S32P: afade->fade_samples = fade_samples_s32p; break;
 +    }
 +
 +    if (afade->duration)
 +        afade->nb_samples = afade->duration * inlink->sample_rate;
 +    if (afade->start_time)
 +        afade->start_sample = afade->start_time * inlink->sample_rate;
 +
 +    return 0;
 +}
 +
-     int nb_samples          = buf->audio->nb_samples;
-     AVFilterBufferRef *out_buf;
++static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
 +{
 +    AudioFadeContext *afade = inlink->dst->priv;
 +    AVFilterLink *outlink   = inlink->dst->outputs[0];
-     if (buf->perms & AV_PERM_WRITE) {
++    int nb_samples          = buf->nb_samples;
++    AVFrame *out_buf;
 +    int64_t cur_sample = av_rescale_q(buf->pts, (AVRational){1, outlink->sample_rate}, outlink->time_base);
 +
 +    if ((!afade->type && (afade->start_sample + afade->nb_samples < cur_sample)) ||
 +        ( afade->type && (cur_sample + afade->nb_samples < afade->start_sample)))
 +        return ff_filter_frame(outlink, buf);
 +
-         out_buf = ff_get_audio_buffer(inlink, AV_PERM_WRITE, nb_samples);
++    if (av_frame_is_writable(buf)) {
 +        out_buf = buf;
 +    } else {
-                                out_buf->audio->channels, out_buf->format);
++        out_buf = ff_get_audio_buffer(inlink, nb_samples);
 +        if (!out_buf)
 +            return AVERROR(ENOMEM);
 +        out_buf->pts = buf->pts;
 +    }
 +
 +    if ((!afade->type && (cur_sample + nb_samples < afade->start_sample)) ||
 +        ( afade->type && (afade->start_sample + afade->nb_samples < cur_sample))) {
 +        av_samples_set_silence(out_buf->extended_data, 0, nb_samples,
-                             nb_samples, buf->audio->channels,
++                               out_buf->channels, out_buf->format);
 +    } else {
 +        int64_t start;
 +
 +        if (!afade->type)
 +            start = cur_sample - afade->start_sample;
 +        else
 +            start = afade->start_sample + afade->nb_samples - cur_sample;
 +
 +        afade->fade_samples(out_buf->extended_data, buf->extended_data,
-         avfilter_unref_buffer(buf);
++                            nb_samples, buf->channels,
 +                            afade->type ? -1 : 1, start,
 +                            afade->nb_samples, afade->curve);
 +    }
 +
 +    if (buf != out_buf)
++        av_frame_free(&buf);
 +
 +    return ff_filter_frame(outlink, out_buf);
 +}
 +
 +static const AVFilterPad avfilter_af_afade_inputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad avfilter_af_afade_outputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .config_props = config_output,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_afade = {
 +    .name          = "afade",
 +    .description   = NULL_IF_CONFIG_SMALL("Fade in/out input audio."),
 +    .query_formats = query_formats,
 +    .priv_size     = sizeof(AudioFadeContext),
 +    .init          = init,
 +    .inputs        = avfilter_af_afade_inputs,
 +    .outputs       = avfilter_af_afade_outputs,
 +    .priv_class    = &afade_class,
 +};
index 2d68ea6,0000000..b26141d
mode 100644,000000..100644
--- /dev/null
@@@ -1,355 -1,0 +1,355 @@@
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)
 +/*
 + * Copyright (c) 2011 Nicolas George <nicolas.george@normalesup.org>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + * GNU Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * Audio merging filter
 + */
 +
 +#include "libavutil/avstring.h"
 +#include "libavutil/bprint.h"
 +#include "libavutil/channel_layout.h"
 +#include "libavutil/opt.h"
 +#include "libswresample/swresample.h" // only for SWR_CH_MAX
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "bufferqueue.h"
 +#include "internal.h"
 +
 +typedef struct {
 +    const AVClass *class;
 +    int nb_inputs;
 +    int route[SWR_CH_MAX]; /**< channels routing, see copy_samples */
 +    int bps;
 +    struct amerge_input {
 +        struct FFBufQueue queue;
 +        int nb_ch;         /**< number of channels for the input */
 +        int nb_samples;
 +        int pos;
 +    } *in;
 +} AMergeContext;
 +
 +#define OFFSET(x) offsetof(AMergeContext, x)
 +#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
 +static const AVOption amerge_options[] = {
 +    { "inputs", "specify the number of inputs", OFFSET(nb_inputs),
 +      AV_OPT_TYPE_INT, { .i64 = 2 }, 2, SWR_CH_MAX, FLAGS },
 +    {0}
 +};
 +
 +AVFILTER_DEFINE_CLASS(amerge);
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    AMergeContext *am = ctx->priv;
 +    int i;
 +
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        if (am->in)
 +            ff_bufqueue_discard_all(&am->in[i].queue);
 +        if (ctx->input_pads)
 +            av_freep(&ctx->input_pads[i].name);
 +    }
 +    av_freep(&am->in);
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    AMergeContext *am = ctx->priv;
 +    int64_t inlayout[SWR_CH_MAX], outlayout = 0;
 +    AVFilterFormats *formats;
 +    AVFilterChannelLayouts *layouts;
 +    int i, overlap = 0, nb_ch = 0;
 +
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        if (!ctx->inputs[i]->in_channel_layouts ||
 +            !ctx->inputs[i]->in_channel_layouts->nb_channel_layouts) {
 +            av_log(ctx, AV_LOG_ERROR,
 +                   "No channel layout for input %d\n", i + 1);
 +            return AVERROR(EINVAL);
 +        }
 +        inlayout[i] = ctx->inputs[i]->in_channel_layouts->channel_layouts[0];
 +        if (ctx->inputs[i]->in_channel_layouts->nb_channel_layouts > 1) {
 +            char buf[256];
 +            av_get_channel_layout_string(buf, sizeof(buf), 0, inlayout[i]);
 +            av_log(ctx, AV_LOG_INFO, "Using \"%s\" for input %d\n", buf, i + 1);
 +        }
 +        am->in[i].nb_ch = av_get_channel_layout_nb_channels(inlayout[i]);
 +        if (outlayout & inlayout[i])
 +            overlap++;
 +        outlayout |= inlayout[i];
 +        nb_ch += am->in[i].nb_ch;
 +    }
 +    if (nb_ch > SWR_CH_MAX) {
 +        av_log(ctx, AV_LOG_ERROR, "Too many channels (max %d)\n", SWR_CH_MAX);
 +        return AVERROR(EINVAL);
 +    }
 +    if (overlap) {
 +        av_log(ctx, AV_LOG_WARNING,
 +               "Input channel layouts overlap: "
 +               "output layout will be determined by the number of distinct input channels\n");
 +        for (i = 0; i < nb_ch; i++)
 +            am->route[i] = i;
 +        outlayout = av_get_default_channel_layout(nb_ch);
 +        if (!outlayout)
 +            outlayout = ((int64_t)1 << nb_ch) - 1;
 +    } else {
 +        int *route[SWR_CH_MAX];
 +        int c, out_ch_number = 0;
 +
 +        route[0] = am->route;
 +        for (i = 1; i < am->nb_inputs; i++)
 +            route[i] = route[i - 1] + am->in[i - 1].nb_ch;
 +        for (c = 0; c < 64; c++)
 +            for (i = 0; i < am->nb_inputs; i++)
 +                if ((inlayout[i] >> c) & 1)
 +                    *(route[i]++) = out_ch_number++;
 +    }
 +    formats = ff_make_format_list(ff_packed_sample_fmts_array);
 +    ff_set_common_formats(ctx, formats);
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        layouts = NULL;
 +        ff_add_channel_layout(&layouts, inlayout[i]);
 +        ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
 +    }
 +    layouts = NULL;
 +    ff_add_channel_layout(&layouts, outlayout);
 +    ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
 +    ff_set_common_samplerates(ctx, ff_all_samplerates());
 +    return 0;
 +}
 +
 +static int config_output(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    AMergeContext *am = ctx->priv;
 +    AVBPrint bp;
 +    int i;
 +
 +    for (i = 1; i < am->nb_inputs; i++) {
 +        if (ctx->inputs[i]->sample_rate != ctx->inputs[0]->sample_rate) {
 +            av_log(ctx, AV_LOG_ERROR,
 +                   "Inputs must have the same sample rate "
 +                   "%d for in%d vs %d\n",
 +                   ctx->inputs[i]->sample_rate, i, ctx->inputs[0]->sample_rate);
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +    am->bps = av_get_bytes_per_sample(ctx->outputs[0]->format);
 +    outlink->sample_rate = ctx->inputs[0]->sample_rate;
 +    outlink->time_base   = ctx->inputs[0]->time_base;
 +
 +    av_bprint_init(&bp, 0, 1);
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        av_bprintf(&bp, "%sin%d:", i ? " + " : "", i);
 +        av_bprint_channel_layout(&bp, -1, ctx->inputs[i]->channel_layout);
 +    }
 +    av_bprintf(&bp, " -> out:");
 +    av_bprint_channel_layout(&bp, -1, ctx->outputs[0]->channel_layout);
 +    av_log(ctx, AV_LOG_VERBOSE, "%s\n", bp.str);
 +
 +    return 0;
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    AMergeContext *am = ctx->priv;
 +    int i, ret;
 +
 +    for (i = 0; i < am->nb_inputs; i++)
 +        if (!am->in[i].nb_samples)
 +            if ((ret = ff_request_frame(ctx->inputs[i])) < 0)
 +                return ret;
 +    return 0;
 +}
 +
 +/**
 + * Copy samples from several input streams to one output stream.
 + * @param nb_inputs number of inputs
 + * @param in        inputs; used only for the nb_ch field;
 + * @param route     routing values;
 + *                  input channel i goes to output channel route[i];
 + *                  i <  in[0].nb_ch are the channels from the first output;
 + *                  i >= in[0].nb_ch are the channels from the second output
 + * @param ins       pointer to the samples of each inputs, in packed format;
 + *                  will be left at the end of the copied samples
 + * @param outs      pointer to the samples of the output, in packet format;
 + *                  must point to a buffer big enough;
 + *                  will be left at the end of the copied samples
 + * @param ns        number of samples to copy
 + * @param bps       bytes per sample
 + */
 +static inline void copy_samples(int nb_inputs, struct amerge_input in[],
 +                                int *route, uint8_t *ins[],
 +                                uint8_t **outs, int ns, int bps)
 +{
 +    int *route_cur;
 +    int i, c, nb_ch = 0;
 +
 +    for (i = 0; i < nb_inputs; i++)
 +        nb_ch += in[i].nb_ch;
 +    while (ns--) {
 +        route_cur = route;
 +        for (i = 0; i < nb_inputs; i++) {
 +            for (c = 0; c < in[i].nb_ch; c++) {
 +                memcpy((*outs) + bps * *(route_cur++), ins[i], bps);
 +                ins[i] += bps;
 +            }
 +        }
 +        *outs += nb_ch * bps;
 +    }
 +}
 +
-     AVFilterBufferRef *outbuf, *inbuf[SWR_CH_MAX];
++static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    AMergeContext *am = ctx->priv;
 +    AVFilterLink *const outlink = ctx->outputs[0];
 +    int input_number;
 +    int nb_samples, ns, i;
-         avfilter_unref_buffer(insamples);
++    AVFrame *outbuf, *inbuf[SWR_CH_MAX];
 +    uint8_t *ins[SWR_CH_MAX], *outs;
 +
 +    for (input_number = 0; input_number < am->nb_inputs; input_number++)
 +        if (inlink == ctx->inputs[input_number])
 +            break;
 +    av_assert1(input_number < am->nb_inputs);
 +    if (ff_bufqueue_is_full(&am->in[input_number].queue)) {
 +        av_log(ctx, AV_LOG_ERROR, "Buffer queue overflow\n");
-     ff_bufqueue_add(ctx, &am->in[input_number].queue, insamples);
-     am->in[input_number].nb_samples += insamples->audio->nb_samples;
++        av_frame_free(&insamples);
 +        return AVERROR(ENOMEM);
 +    }
-     outbuf = ff_get_audio_buffer(ctx->outputs[0], AV_PERM_WRITE, nb_samples);
++    ff_bufqueue_add(ctx, &am->in[input_number].queue, av_frame_clone(insamples));
++    am->in[input_number].nb_samples += insamples->nb_samples;
++    av_frame_free(&insamples);
 +    nb_samples = am->in[0].nb_samples;
 +    for (i = 1; i < am->nb_inputs; i++)
 +        nb_samples = FFMIN(nb_samples, am->in[i].nb_samples);
 +    if (!nb_samples)
 +        return 0;
 +
-     avfilter_copy_buffer_ref_props(outbuf, inbuf[0]);
++    outbuf = ff_get_audio_buffer(ctx->outputs[0], nb_samples);
 +    outs = outbuf->data[0];
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        inbuf[i] = ff_bufqueue_peek(&am->in[i].queue, 0);
 +        ins[i] = inbuf[i]->data[0] +
 +                 am->in[i].pos * am->in[i].nb_ch * am->bps;
 +    }
-     outbuf->audio->nb_samples     = nb_samples;
-     outbuf->audio->channel_layout = outlink->channel_layout;
-     outbuf->audio->channels       = outlink->channels;
++    av_frame_copy_props(outbuf, inbuf[0]);
 +    outbuf->pts = inbuf[0]->pts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
 +                  inbuf[0]->pts +
 +                  av_rescale_q(am->in[0].pos,
 +                               (AVRational){ 1, ctx->inputs[0]->sample_rate },
 +                               ctx->outputs[0]->time_base);
 +
-             ns = FFMIN(ns, inbuf[i]->audio->nb_samples - am->in[i].pos);
++    outbuf->nb_samples     = nb_samples;
++    outbuf->channel_layout = outlink->channel_layout;
++    outbuf->channels       = outlink->channels;
 +
 +    while (nb_samples) {
 +        ns = nb_samples;
 +        for (i = 0; i < am->nb_inputs; i++)
-             if (am->in[i].pos == inbuf[i]->audio->nb_samples) {
++            ns = FFMIN(ns, inbuf[i]->nb_samples - am->in[i].pos);
 +        /* Unroll the most common sample formats: speed +~350% for the loop,
 +           +~13% overall (including two common decoders) */
 +        switch (am->bps) {
 +            case 1:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, 1);
 +                break;
 +            case 2:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, 2);
 +                break;
 +            case 4:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, 4);
 +                break;
 +            default:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, am->bps);
 +                break;
 +        }
 +
 +        nb_samples -= ns;
 +        for (i = 0; i < am->nb_inputs; i++) {
 +            am->in[i].nb_samples -= ns;
 +            am->in[i].pos += ns;
-                 avfilter_unref_buffer(inbuf[i]);
++            if (am->in[i].pos == inbuf[i]->nb_samples) {
 +                am->in[i].pos = 0;
-             .min_perms        = AV_PERM_READ | AV_PERM_PRESERVE,
++                av_frame_free(&inbuf[i]);
 +                ff_bufqueue_get(&am->in[i].queue);
 +                inbuf[i] = ff_bufqueue_peek(&am->in[i].queue, 0);
 +                ins[i] = inbuf[i] ? inbuf[i]->data[0] : NULL;
 +            }
 +        }
 +    }
 +    return ff_filter_frame(ctx->outputs[0], outbuf);
 +}
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    AMergeContext *am = ctx->priv;
 +    int ret, i;
 +
 +    am->class = &amerge_class;
 +    av_opt_set_defaults(am);
 +    ret = av_set_options_string(am, args, "=", ":");
 +    if (ret < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Error parsing options: '%s'\n", args);
 +        return ret;
 +    }
 +    am->in = av_calloc(am->nb_inputs, sizeof(*am->in));
 +    if (!am->in)
 +        return AVERROR(ENOMEM);
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        char *name = av_asprintf("in%d", i);
 +        AVFilterPad pad = {
 +            .name             = name,
 +            .type             = AVMEDIA_TYPE_AUDIO,
 +            .filter_frame     = filter_frame,
 +        };
 +        if (!name)
 +            return AVERROR(ENOMEM);
 +        ff_insert_inpad(ctx, i, &pad);
 +    }
 +    return 0;
 +}
 +
 +static const AVFilterPad amerge_outputs[] = {
 +    {
 +        .name          = "default",
 +        .type          = AVMEDIA_TYPE_AUDIO,
 +        .config_props  = config_output,
 +        .request_frame = request_frame,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_amerge = {
 +    .name          = "amerge",
 +    .description   = NULL_IF_CONFIG_SMALL("Merge two or more audio streams into "
 +                                          "a single multi-channel stream."),
 +    .priv_size     = sizeof(AMergeContext),
 +    .init          = init,
 +    .uninit        = uninit,
 +    .query_formats = query_formats,
 +    .inputs        = NULL,
 +    .outputs       = amerge_outputs,
 +    .priv_class    = &amerge_class,
 +};
Simple merge
index 18a0170,0000000..2afd3a8
mode 100644,000000..100644
--- /dev/null
@@@ -1,164 -1,0 +1,164 @@@
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *frame)
 +/*
 + * Copyright (c) 2012 Michael Niedermayer
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + *
 + */
 +
 +/**
 + * @file
 + * audio pad filter.
 + *
 + * Based on af_aresample.c
 + */
 +
 +#include "libavutil/avstring.h"
 +#include "libavutil/channel_layout.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/samplefmt.h"
 +#include "libavutil/avassert.h"
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "internal.h"
 +
 +typedef struct {
 +    const AVClass *class;
 +    int64_t next_pts;
 +
 +    int packet_size;
 +    int64_t pad_len;
 +    int64_t whole_len;
 +} APadContext;
 +
 +#define OFFSET(x) offsetof(APadContext, x)
 +#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
 +static const AVOption apad_options[] = {
 +    { "packet_size", "set silence packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, { .i64 = 4096 }, 0, INT_MAX, A },
 +    { "pad_len",     "number of samples of silence to add",          OFFSET(pad_len),   AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, A },
 +    { "whole_len",   "target number of samples in the audio stream", OFFSET(whole_len), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, A },
 +    { NULL },
 +};
 +
 +AVFILTER_DEFINE_CLASS(apad);
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    int ret;
 +    APadContext *apad = ctx->priv;
 +
 +    apad->class = &apad_class;
 +    apad->next_pts = AV_NOPTS_VALUE;
 +
 +    av_opt_set_defaults(apad);
 +
 +    if ((ret = av_opt_set_from_string(apad, args, NULL, "=", ":")) < 0)
 +        return ret;
 +
 +    if (apad->whole_len && apad->pad_len) {
 +        av_log(ctx, AV_LOG_ERROR, "Both whole and pad length are set, this is not possible\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    return 0;
 +}
 +
-         apad->whole_len -= frame->audio->nb_samples;
++static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    APadContext *apad = ctx->priv;
 +
 +    if (apad->whole_len)
-     apad->next_pts = frame->pts + av_rescale_q(frame->audio->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
++        apad->whole_len -= frame->nb_samples;
 +
-         AVFilterBufferRef *outsamplesref;
++    apad->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
 +    return ff_filter_frame(ctx->outputs[0], frame);
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    APadContext *apad = ctx->priv;
 +    int ret;
 +
 +    ret = ff_request_frame(ctx->inputs[0]);
 +
 +    if (ret == AVERROR_EOF) {
 +        int n_out = apad->packet_size;
-         outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n_out);
++        AVFrame *outsamplesref;
 +
 +        if (apad->whole_len > 0) {
 +            apad->pad_len = apad->whole_len;
 +            apad->whole_len = 0;
 +        }
 +        if (apad->pad_len > 0) {
 +            n_out = FFMIN(n_out, apad->pad_len);
 +            apad->pad_len -= n_out;
 +        }
 +
 +        if(!n_out)
 +            return AVERROR_EOF;
 +
-         av_assert0(outsamplesref->audio->sample_rate == outlink->sample_rate);
-         av_assert0(outsamplesref->audio->nb_samples  == n_out);
++        outsamplesref = ff_get_audio_buffer(outlink, n_out);
 +        if (!outsamplesref)
 +            return AVERROR(ENOMEM);
 +
-                                outsamplesref->audio->channels,
++        av_assert0(outsamplesref->sample_rate == outlink->sample_rate);
++        av_assert0(outsamplesref->nb_samples  == n_out);
 +
 +        av_samples_set_silence(outsamplesref->extended_data, 0,
 +                               n_out,
++                               outsamplesref->channels,
 +                               outsamplesref->format);
 +
 +        outsamplesref->pts = apad->next_pts;
 +        if (apad->next_pts != AV_NOPTS_VALUE)
 +            apad->next_pts += av_rescale_q(n_out, (AVRational){1, outlink->sample_rate}, outlink->time_base);
 +
 +        return ff_filter_frame(outlink, outsamplesref);
 +    }
 +    return ret;
 +}
 +
 +static const AVFilterPad apad_inputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +        .min_perms    = AV_PERM_READ,
 +    },
 +    { NULL },
 +};
 +
 +static const AVFilterPad apad_outputs[] = {
 +    {
 +        .name          = "default",
 +        .request_frame = request_frame,
 +        .type          = AVMEDIA_TYPE_AUDIO,
 +    },
 +    { NULL },
 +};
 +
 +AVFilter avfilter_af_apad = {
 +    .name          = "apad",
 +    .description   = NULL_IF_CONFIG_SMALL("Pad audio with silence."),
 +    .init          = init,
 +    .priv_size     = sizeof(APadContext),
 +    .inputs        = apad_inputs,
 +    .outputs       = apad_outputs,
 +    .priv_class    = &apad_class,
 +};
index 66a8a53,0000000..6e0d679
mode 100644,000000..100644
--- /dev/null
@@@ -1,290 -1,0 +1,289 @@@
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)
 +/*
 + * Copyright (c) 2011 Stefano Sabatini
 + * Copyright (c) 2011 Mina Nagy Zaki
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * resampling audio filter
 + */
 +
 +#include "libavutil/avstring.h"
 +#include "libavutil/channel_layout.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/samplefmt.h"
 +#include "libavutil/avassert.h"
 +#include "libswresample/swresample.h"
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "internal.h"
 +
 +typedef struct {
 +    double ratio;
 +    struct SwrContext *swr;
 +    int64_t next_pts;
 +    int req_fullfilled;
 +} AResampleContext;
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    AResampleContext *aresample = ctx->priv;
 +    int ret = 0;
 +    char *argd = av_strdup(args);
 +
 +    aresample->next_pts = AV_NOPTS_VALUE;
 +    aresample->swr = swr_alloc();
 +    if (!aresample->swr) {
 +        ret = AVERROR(ENOMEM);
 +        goto end;
 +    }
 +
 +    if (args) {
 +        char *ptr = argd, *token;
 +
 +        while (token = av_strtok(ptr, ":", &ptr)) {
 +            char *value;
 +            av_strtok(token, "=", &value);
 +
 +            if (value) {
 +                if ((ret = av_opt_set(aresample->swr, token, value, 0)) < 0)
 +                    goto end;
 +            } else {
 +                int out_rate;
 +                if ((ret = ff_parse_sample_rate(&out_rate, token, ctx)) < 0)
 +                    goto end;
 +                if ((ret = av_opt_set_int(aresample->swr, "osr", out_rate, 0)) < 0)
 +                    goto end;
 +            }
 +        }
 +    }
 +end:
 +    av_free(argd);
 +    return ret;
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    AResampleContext *aresample = ctx->priv;
 +    swr_free(&aresample->swr);
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    AResampleContext *aresample = ctx->priv;
 +    int out_rate                   = av_get_int(aresample->swr, "osr", NULL);
 +    uint64_t out_layout            = av_get_int(aresample->swr, "ocl", NULL);
 +    enum AVSampleFormat out_format = av_get_int(aresample->swr, "osf", NULL);
 +
 +    AVFilterLink *inlink  = ctx->inputs[0];
 +    AVFilterLink *outlink = ctx->outputs[0];
 +
 +    AVFilterFormats        *in_formats      = ff_all_formats(AVMEDIA_TYPE_AUDIO);
 +    AVFilterFormats        *out_formats;
 +    AVFilterFormats        *in_samplerates  = ff_all_samplerates();
 +    AVFilterFormats        *out_samplerates;
 +    AVFilterChannelLayouts *in_layouts      = ff_all_channel_counts();
 +    AVFilterChannelLayouts *out_layouts;
 +
 +    ff_formats_ref  (in_formats,      &inlink->out_formats);
 +    ff_formats_ref  (in_samplerates,  &inlink->out_samplerates);
 +    ff_channel_layouts_ref(in_layouts,      &inlink->out_channel_layouts);
 +
 +    if(out_rate > 0) {
 +        out_samplerates = ff_make_format_list((int[]){ out_rate, -1 });
 +    } else {
 +        out_samplerates = ff_all_samplerates();
 +    }
 +    ff_formats_ref(out_samplerates, &outlink->in_samplerates);
 +
 +    if(out_format != AV_SAMPLE_FMT_NONE) {
 +        out_formats = ff_make_format_list((int[]){ out_format, -1 });
 +    } else
 +        out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
 +    ff_formats_ref(out_formats, &outlink->in_formats);
 +
 +    if(out_layout) {
 +        out_layouts = avfilter_make_format64_list((int64_t[]){ out_layout, -1 });
 +    } else
 +        out_layouts = ff_all_channel_counts();
 +    ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
 +
 +    return 0;
 +}
 +
 +
 +static int config_output(AVFilterLink *outlink)
 +{
 +    int ret;
 +    AVFilterContext *ctx = outlink->src;
 +    AVFilterLink *inlink = ctx->inputs[0];
 +    AResampleContext *aresample = ctx->priv;
 +    int out_rate;
 +    uint64_t out_layout;
 +    enum AVSampleFormat out_format;
 +    char inchl_buf[128], outchl_buf[128];
 +
 +    aresample->swr = swr_alloc_set_opts(aresample->swr,
 +                                        outlink->channel_layout, outlink->format, outlink->sample_rate,
 +                                        inlink->channel_layout, inlink->format, inlink->sample_rate,
 +                                        0, ctx);
 +    if (!aresample->swr)
 +        return AVERROR(ENOMEM);
 +    if (!inlink->channel_layout)
 +        av_opt_set_int(aresample->swr, "ich", inlink->channels, 0);
 +    if (!outlink->channel_layout)
 +        av_opt_set_int(aresample->swr, "och", outlink->channels, 0);
 +
 +    ret = swr_init(aresample->swr);
 +    if (ret < 0)
 +        return ret;
 +
 +    out_rate   = av_get_int(aresample->swr, "osr", NULL);
 +    out_layout = av_get_int(aresample->swr, "ocl", NULL);
 +    out_format = av_get_int(aresample->swr, "osf", NULL);
 +    outlink->time_base = (AVRational) {1, out_rate};
 +
 +    av_assert0(outlink->sample_rate == out_rate);
 +    av_assert0(outlink->channel_layout == out_layout || !outlink->channel_layout);
 +    av_assert0(outlink->format == out_format);
 +
 +    aresample->ratio = (double)outlink->sample_rate / inlink->sample_rate;
 +
 +    av_get_channel_layout_string(inchl_buf,  sizeof(inchl_buf),  inlink ->channels, inlink ->channel_layout);
 +    av_get_channel_layout_string(outchl_buf, sizeof(outchl_buf), outlink->channels, outlink->channel_layout);
 +
 +    av_log(ctx, AV_LOG_VERBOSE, "ch:%d chl:%s fmt:%s r:%dHz -> ch:%d chl:%s fmt:%s r:%dHz\n",
 +           inlink ->channels, inchl_buf,  av_get_sample_fmt_name(inlink->format),  inlink->sample_rate,
 +           outlink->channels, outchl_buf, av_get_sample_fmt_name(outlink->format), outlink->sample_rate);
 +    return 0;
 +}
 +
-     const int n_in  = insamplesref->audio->nb_samples;
++static int filter_frame(AVFilterLink *inlink, AVFrame *insamplesref)
 +{
 +    AResampleContext *aresample = inlink->dst->priv;
-     AVFilterBufferRef *outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n_out);
++    const int n_in  = insamplesref->nb_samples;
 +    int n_out       = n_in * aresample->ratio * 2 + 256;
 +    AVFilterLink *const outlink = inlink->dst->outputs[0];
-     avfilter_copy_buffer_ref_props(outsamplesref, insamplesref);
++    AVFrame *outsamplesref = ff_get_audio_buffer(outlink, n_out);
 +    int ret;
 +
 +    if(!outsamplesref)
 +        return AVERROR(ENOMEM);
 +
-     outsamplesref->audio->channels       = outlink->channels;
-     outsamplesref->audio->channel_layout = outlink->channel_layout;
-     outsamplesref->audio->sample_rate    = outlink->sample_rate;
++    av_frame_copy_props(outsamplesref, insamplesref);
 +    outsamplesref->format                = outlink->format;
-         avfilter_unref_buffer(outsamplesref);
-         avfilter_unref_buffer(insamplesref);
++    outsamplesref->channels              = outlink->channels;
++    outsamplesref->channel_layout        = outlink->channel_layout;
++    outsamplesref->sample_rate           = outlink->sample_rate;
 +
 +    if(insamplesref->pts != AV_NOPTS_VALUE) {
 +        int64_t inpts = av_rescale(insamplesref->pts, inlink->time_base.num * (int64_t)outlink->sample_rate * inlink->sample_rate, inlink->time_base.den);
 +        int64_t outpts= swr_next_pts(aresample->swr, inpts);
 +        aresample->next_pts =
 +        outsamplesref->pts  = ROUNDED_DIV(outpts, inlink->sample_rate);
 +    } else {
 +        outsamplesref->pts  = AV_NOPTS_VALUE;
 +    }
 +    n_out = swr_convert(aresample->swr, outsamplesref->extended_data, n_out,
 +                                 (void *)insamplesref->extended_data, n_in);
 +    if (n_out <= 0) {
-     outsamplesref->audio->nb_samples  = n_out;
++        av_frame_free(&outsamplesref);
++        av_frame_free(&insamplesref);
 +        return 0;
 +    }
 +
-     avfilter_unref_buffer(insamplesref);
++    outsamplesref->nb_samples  = n_out;
 +
 +    ret = ff_filter_frame(outlink, outsamplesref);
 +    aresample->req_fullfilled= 1;
-         AVFilterBufferRef *outsamplesref;
++    av_frame_free(&insamplesref);
 +    return ret;
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    AResampleContext *aresample = ctx->priv;
 +    AVFilterLink *const inlink = outlink->src->inputs[0];
 +    int ret;
 +
 +    aresample->req_fullfilled = 0;
 +    do{
 +        ret = ff_request_frame(ctx->inputs[0]);
 +    }while(!aresample->req_fullfilled && ret>=0);
 +
 +    if (ret == AVERROR_EOF) {
-         outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n_out);
++        AVFrame *outsamplesref;
 +        int n_out = 4096;
 +
-             avfilter_unref_buffer(outsamplesref);
++        outsamplesref = ff_get_audio_buffer(outlink, n_out);
 +        if (!outsamplesref)
 +            return AVERROR(ENOMEM);
 +        n_out = swr_convert(aresample->swr, outsamplesref->extended_data, n_out, 0, 0);
 +        if (n_out <= 0) {
-         outsamplesref->audio->sample_rate = outlink->sample_rate;
-         outsamplesref->audio->nb_samples  = n_out;
++            av_frame_free(&outsamplesref);
 +            return (n_out == 0) ? AVERROR_EOF : n_out;
 +        }
 +
-         .min_perms    = AV_PERM_READ,
++        outsamplesref->sample_rate = outlink->sample_rate;
++        outsamplesref->nb_samples  = n_out;
 +#if 0
 +        outsamplesref->pts = aresample->next_pts;
 +        if(aresample->next_pts != AV_NOPTS_VALUE)
 +            aresample->next_pts += av_rescale_q(n_out, (AVRational){1 ,outlink->sample_rate}, outlink->time_base);
 +#else
 +        outsamplesref->pts = swr_next_pts(aresample->swr, INT64_MIN);
 +        outsamplesref->pts = ROUNDED_DIV(outsamplesref->pts, inlink->sample_rate);
 +#endif
 +
 +        ff_filter_frame(outlink, outsamplesref);
 +        return 0;
 +    }
 +    return ret;
 +}
 +
 +static const AVFilterPad aresample_inputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +    },
 +    { NULL },
 +};
 +
 +static const AVFilterPad aresample_outputs[] = {
 +    {
 +        .name          = "default",
 +        .config_props  = config_output,
 +        .request_frame = request_frame,
 +        .type          = AVMEDIA_TYPE_AUDIO,
 +    },
 +    { NULL },
 +};
 +
 +AVFilter avfilter_af_aresample = {
 +    .name          = "aresample",
 +    .description   = NULL_IF_CONFIG_SMALL("Resample audio data."),
 +    .init          = init,
 +    .uninit        = uninit,
 +    .query_formats = query_formats,
 +    .priv_size     = sizeof(AResampleContext),
 +    .inputs        = aresample_inputs,
 +    .outputs       = aresample_outputs,
 +};
index ee80c1c,0000000..f995ce9
mode 100644,000000..100644
--- /dev/null
@@@ -1,207 -1,0 +1,207 @@@
-     AVFilterBufferRef *outsamples = NULL;
 +/*
 + * Copyright (c) 2012 Andrey Utkin
 + * Copyright (c) 2012 Stefano Sabatini
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * Filter that changes number of samples on single output operation
 + */
 +
 +#include "libavutil/audio_fifo.h"
 +#include "libavutil/avassert.h"
 +#include "libavutil/channel_layout.h"
 +#include "libavutil/opt.h"
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "internal.h"
 +#include "formats.h"
 +
 +typedef struct {
 +    const AVClass *class;
 +    int nb_out_samples;  ///< how many samples to output
 +    AVAudioFifo *fifo;   ///< samples are queued here
 +    int64_t next_out_pts;
 +    int req_fullfilled;
 +    int pad;
 +} ASNSContext;
 +
 +#define OFFSET(x) offsetof(ASNSContext, x)
 +#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
 +static const AVOption asetnsamples_options[] = {
 +{ "pad", "pad last frame with zeros", OFFSET(pad), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS },
 +{ "p",   "pad last frame with zeros", OFFSET(pad), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS },
 +{ "nb_out_samples", "set the number of per-frame output samples", OFFSET(nb_out_samples), AV_OPT_TYPE_INT, {.i64=1024}, 1, INT_MAX, FLAGS },
 +{ "n",              "set the number of per-frame output samples", OFFSET(nb_out_samples), AV_OPT_TYPE_INT, {.i64=1024}, 1, INT_MAX, FLAGS },
 +{ NULL }
 +};
 +
 +AVFILTER_DEFINE_CLASS(asetnsamples);
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    ASNSContext *asns = ctx->priv;
 +    int err;
 +
 +    asns->class = &asetnsamples_class;
 +    av_opt_set_defaults(asns);
 +
 +    if ((err = av_set_options_string(asns, args, "=", ":")) < 0)
 +        return err;
 +
 +    asns->next_out_pts = AV_NOPTS_VALUE;
 +    av_log(ctx, AV_LOG_VERBOSE, "nb_out_samples:%d pad:%d\n", asns->nb_out_samples, asns->pad);
 +
 +    return 0;
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    ASNSContext *asns = ctx->priv;
 +    av_audio_fifo_free(asns->fifo);
 +}
 +
 +static int config_props_output(AVFilterLink *outlink)
 +{
 +    ASNSContext *asns = outlink->src->priv;
 +    int nb_channels = av_get_channel_layout_nb_channels(outlink->channel_layout);
 +
 +    asns->fifo = av_audio_fifo_alloc(outlink->format, nb_channels, asns->nb_out_samples);
 +    if (!asns->fifo)
 +        return AVERROR(ENOMEM);
 +
 +    return 0;
 +}
 +
 +static int push_samples(AVFilterLink *outlink)
 +{
 +    ASNSContext *asns = outlink->src->priv;
-     outsamples = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_out_samples);
++    AVFrame *outsamples = NULL;
 +    int nb_out_samples, nb_pad_samples;
 +
 +    if (asns->pad) {
 +        nb_out_samples = av_audio_fifo_size(asns->fifo) ? asns->nb_out_samples : 0;
 +        nb_pad_samples = nb_out_samples - FFMIN(nb_out_samples, av_audio_fifo_size(asns->fifo));
 +    } else {
 +        nb_out_samples = FFMIN(asns->nb_out_samples, av_audio_fifo_size(asns->fifo));
 +        nb_pad_samples = 0;
 +    }
 +
 +    if (!nb_out_samples)
 +        return 0;
 +
-     outsamples->audio->nb_samples     = nb_out_samples;
-     outsamples->audio->channel_layout = outlink->channel_layout;
-     outsamples->audio->sample_rate    = outlink->sample_rate;
++    outsamples = ff_get_audio_buffer(outlink, nb_out_samples);
 +    av_assert0(outsamples);
 +
 +    av_audio_fifo_read(asns->fifo,
 +                       (void **)outsamples->extended_data, nb_out_samples);
 +
 +    if (nb_pad_samples)
 +        av_samples_set_silence(outsamples->extended_data, nb_out_samples - nb_pad_samples,
 +                               nb_pad_samples, av_get_channel_layout_nb_channels(outlink->channel_layout),
 +                               outlink->format);
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)
++    outsamples->nb_samples     = nb_out_samples;
++    outsamples->channel_layout = outlink->channel_layout;
++    outsamples->sample_rate    = outlink->sample_rate;
 +    outsamples->pts = asns->next_out_pts;
 +
 +    if (asns->next_out_pts != AV_NOPTS_VALUE)
 +        asns->next_out_pts += nb_out_samples;
 +
 +    ff_filter_frame(outlink, outsamples);
 +    asns->req_fullfilled = 1;
 +    return nb_out_samples;
 +}
 +
-     int nb_samples = insamples->audio->nb_samples;
++static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    ASNSContext *asns = ctx->priv;
 +    AVFilterLink *outlink = ctx->outputs[0];
 +    int ret;
-     avfilter_unref_buffer(insamples);
++    int nb_samples = insamples->nb_samples;
 +
 +    if (av_audio_fifo_space(asns->fifo) < nb_samples) {
 +        av_log(ctx, AV_LOG_DEBUG, "No space for %d samples, stretching audio fifo\n", nb_samples);
 +        ret = av_audio_fifo_realloc(asns->fifo, av_audio_fifo_size(asns->fifo) + nb_samples);
 +        if (ret < 0) {
 +            av_log(ctx, AV_LOG_ERROR,
 +                   "Stretching audio fifo failed, discarded %d samples\n", nb_samples);
 +            return -1;
 +        }
 +    }
 +    av_audio_fifo_write(asns->fifo, (void **)insamples->extended_data, nb_samples);
 +    if (asns->next_out_pts == AV_NOPTS_VALUE)
 +        asns->next_out_pts = insamples->pts;
-         .name         = "default",
-         .type         = AVMEDIA_TYPE_AUDIO,
-         .filter_frame = filter_frame,
-         .min_perms    = AV_PERM_READ | AV_PERM_WRITE,
++    av_frame_free(&insamples);
 +
 +    while (av_audio_fifo_size(asns->fifo) >= asns->nb_out_samples)
 +        push_samples(outlink);
 +    return 0;
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    ASNSContext *asns = outlink->src->priv;
 +    AVFilterLink *inlink = outlink->src->inputs[0];
 +    int ret;
 +
 +    asns->req_fullfilled = 0;
 +    do {
 +        ret = ff_request_frame(inlink);
 +    } while (!asns->req_fullfilled && ret >= 0);
 +
 +    if (ret == AVERROR_EOF)
 +        while (push_samples(outlink))
 +            ;
 +
 +    return ret;
 +}
 +
 +static const AVFilterPad asetnsamples_inputs[] = {
 +    {
++        .name           = "default",
++        .type           = AVMEDIA_TYPE_AUDIO,
++        .filter_frame   = filter_frame,
++        .needs_writable = 1,
 +    },
 +    {  NULL }
 +};
 +
 +static const AVFilterPad asetnsamples_outputs[] = {
 +    {
 +        .name          = "default",
 +        .type          = AVMEDIA_TYPE_AUDIO,
 +        .request_frame = request_frame,
 +        .config_props  = config_props_output,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_asetnsamples = {
 +    .name           = "asetnsamples",
 +    .description    = NULL_IF_CONFIG_SMALL("Set the number of samples for each output audio frames."),
 +    .priv_size      = sizeof(ASNSContext),
 +    .init           = init,
 +    .uninit         = uninit,
 +    .inputs         = asetnsamples_inputs,
 +    .outputs        = asetnsamples_outputs,
 +    .priv_class     = &asetnsamples_class,
 +};
@@@ -61,17 -71,12 +61,17 @@@ static int filter_frame(AVFilterLink *i
      AShowInfoContext *s  = ctx->priv;
      char chlayout_str[128];
      uint32_t checksum = 0;
-     int channels    = av_get_channel_layout_nb_channels(buf->audio->channel_layout);
+     int channels    = av_get_channel_layout_nb_channels(buf->channel_layout);
      int planar      = av_sample_fmt_is_planar(buf->format);
      int block_align = av_get_bytes_per_sample(buf->format) * (planar ? 1 : channels);
-     int data_size   = buf->audio->nb_samples * block_align;
+     int data_size   = buf->nb_samples * block_align;
      int planes      = planar ? channels : 1;
      int i;
 +    void *tmp_ptr = av_realloc(s->plane_checksums, channels * sizeof(*s->plane_checksums));
 +
 +    if (!tmp_ptr)
 +        return AVERROR(ENOMEM);
 +    s->plane_checksums = tmp_ptr;
  
      for (i = 0; i < planes; i++) {
          uint8_t *data = buf->extended_data[i];
      }
  
      av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), -1,
-                                  buf->audio->channel_layout);
+                                  buf->channel_layout);
  
      av_log(ctx, AV_LOG_INFO,
 -           "n:%"PRIu64" pts:%"PRId64" pts_time:%f "
 -           "fmt:%s chlayout:%s rate:%d nb_samples:%d "
 +           "n:%"PRIu64" pts:%s pts_time:%s pos:%"PRId64" "
 +           "fmt:%s channels:%d chlayout:%s rate:%d nb_samples:%d "
             "checksum:%08X ",
 -           s->frame, buf->pts, buf->pts * av_q2d(inlink->time_base),
 -           av_get_sample_fmt_name(buf->format), chlayout_str,
 +           s->frame,
 +           av_ts2str(buf->pts), av_ts2timestr(buf->pts, &inlink->time_base),
-            buf->pos,
-            av_get_sample_fmt_name(buf->format), buf->audio->channels, chlayout_str,
-            buf->audio->sample_rate, buf->audio->nb_samples,
++           av_frame_get_pkt_pos(buf),
++           av_get_sample_fmt_name(buf->format), av_frame_get_channels(buf), chlayout_str,
+            buf->sample_rate, buf->nb_samples,
             checksum);
  
      av_log(ctx, AV_LOG_INFO, "plane_checksums: [ ");
@@@ -109,8 -112,8 +109,7 @@@ static const AVFilterPad inputs[] = 
          .name       = "default",
          .type             = AVMEDIA_TYPE_AUDIO,
          .get_audio_buffer = ff_null_get_audio_buffer,
 -        .config_props     = config_input,
          .filter_frame     = filter_frame,
-         .min_perms        = AV_PERM_READ,
      },
      { NULL },
  };
index 269ffc1,0000000..79f703a
mode 100644,000000..100644
--- /dev/null
@@@ -1,222 -1,0 +1,220 @@@
-         AVFilterBufferRef *buf[QUEUE_SIZE];
 +/*
 + * Copyright (c) 2011 Nicolas George <nicolas.george@normalesup.org>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + * GNU Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * Stream (de)synchronization filter
 + */
 +
 +#include "libavutil/eval.h"
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "internal.h"
 +
 +#define QUEUE_SIZE 16
 +
 +static const char * const var_names[] = {
 +    "b1", "b2",
 +    "s1", "s2",
 +    "t1", "t2",
 +    NULL
 +};
 +
 +enum var_name {
 +    VAR_B1, VAR_B2,
 +    VAR_S1, VAR_S2,
 +    VAR_T1, VAR_T2,
 +    VAR_NB
 +};
 +
 +typedef struct {
 +    AVExpr *expr;
 +    double var_values[VAR_NB];
 +    struct buf_queue {
-     AVFilterBufferRef *buf = queue->buf[queue->tail];
++        AVFrame *buf[QUEUE_SIZE];
 +        unsigned tail, nb;
 +        /* buf[tail] is the oldest,
 +           buf[(tail + nb) % QUEUE_SIZE] is where the next is added */
 +    } queue[2];
 +    int req[2];
 +    int next_out;
 +    int eof; /* bitmask, one bit for each stream */
 +} AStreamSyncContext;
 +
 +static const char *default_expr = "t1-t2";
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args0)
 +{
 +    AStreamSyncContext *as = ctx->priv;
 +    const char *expr = args0 ? args0 : default_expr;
 +    int r, i;
 +
 +    r = av_expr_parse(&as->expr, expr, var_names,
 +                      NULL, NULL, NULL, NULL, 0, ctx);
 +    if (r < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Error in expression \"%s\"\n", expr);
 +        return r;
 +    }
 +    for (i = 0; i < 42; i++)
 +        av_expr_eval(as->expr, as->var_values, NULL); /* exercize prng */
 +    return 0;
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    int i;
 +    AVFilterFormats *formats, *rates;
 +    AVFilterChannelLayouts *layouts;
 +
 +    for (i = 0; i < 2; i++) {
 +        formats = ctx->inputs[i]->in_formats;
 +        ff_formats_ref(formats, &ctx->inputs[i]->out_formats);
 +        ff_formats_ref(formats, &ctx->outputs[i]->in_formats);
 +        rates = ff_all_samplerates();
 +        ff_formats_ref(rates, &ctx->inputs[i]->out_samplerates);
 +        ff_formats_ref(rates, &ctx->outputs[i]->in_samplerates);
 +        layouts = ctx->inputs[i]->in_channel_layouts;
 +        ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
 +        ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts);
 +    }
 +    return 0;
 +}
 +
 +static int config_output(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    int id = outlink == ctx->outputs[1];
 +
 +    outlink->sample_rate = ctx->inputs[id]->sample_rate;
 +    outlink->time_base   = ctx->inputs[id]->time_base;
 +    return 0;
 +}
 +
 +static int send_out(AVFilterContext *ctx, int out_id)
 +{
 +    AStreamSyncContext *as = ctx->priv;
 +    struct buf_queue *queue = &as->queue[out_id];
-     as->var_values[VAR_S1 + out_id] += buf->audio->nb_samples;
++    AVFrame *buf = queue->buf[queue->tail];
 +    int ret;
 +
 +    queue->buf[queue->tail] = NULL;
 +    as->var_values[VAR_B1 + out_id]++;
-     as->var_values[VAR_T1 + out_id] += buf->audio->nb_samples /
++    as->var_values[VAR_S1 + out_id] += buf->nb_samples;
 +    if (buf->pts != AV_NOPTS_VALUE)
 +        as->var_values[VAR_T1 + out_id] =
 +            av_q2d(ctx->outputs[out_id]->time_base) * buf->pts;
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)
++    as->var_values[VAR_T1 + out_id] += buf->nb_samples /
 +                                   (double)ctx->inputs[out_id]->sample_rate;
 +    ret = ff_filter_frame(ctx->outputs[out_id], buf);
 +    queue->nb--;
 +    queue->tail = (queue->tail + 1) % QUEUE_SIZE;
 +    if (as->req[out_id])
 +        as->req[out_id]--;
 +    return ret;
 +}
 +
 +static void send_next(AVFilterContext *ctx)
 +{
 +    AStreamSyncContext *as = ctx->priv;
 +    int i;
 +
 +    while (1) {
 +        if (!as->queue[as->next_out].nb)
 +            break;
 +        send_out(ctx, as->next_out);
 +        if (!as->eof)
 +            as->next_out = av_expr_eval(as->expr, as->var_values, NULL) >= 0;
 +    }
 +    for (i = 0; i < 2; i++)
 +        if (as->queue[i].nb == QUEUE_SIZE)
 +            send_out(ctx, i);
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    AStreamSyncContext *as = ctx->priv;
 +    int id = outlink == ctx->outputs[1];
 +
 +    as->req[id]++;
 +    while (as->req[id] && !(as->eof & (1 << id))) {
 +        if (as->queue[as->next_out].nb) {
 +            send_next(ctx);
 +        } else {
 +            as->eof |= 1 << as->next_out;
 +            ff_request_frame(ctx->inputs[as->next_out]);
 +            if (as->eof & (1 << as->next_out))
 +                as->next_out = !as->next_out;
 +        }
 +    }
 +    return 0;
 +}
 +
-         .min_perms    = AV_PERM_READ | AV_PERM_PRESERVE,
++static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    AStreamSyncContext *as = ctx->priv;
 +    int id = inlink == ctx->inputs[1];
 +
 +    as->queue[id].buf[(as->queue[id].tail + as->queue[id].nb++) % QUEUE_SIZE] =
 +        insamples;
 +    as->eof &= ~(1 << id);
 +    send_next(ctx);
 +    return 0;
 +}
 +
 +static const AVFilterPad astreamsync_inputs[] = {
 +    {
 +        .name         = "in1",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
-         .min_perms    = AV_PERM_READ | AV_PERM_PRESERVE,
 +    },{
 +        .name         = "in2",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad astreamsync_outputs[] = {
 +    {
 +        .name          = "out1",
 +        .type          = AVMEDIA_TYPE_AUDIO,
 +        .config_props  = config_output,
 +        .request_frame = request_frame,
 +    },{
 +        .name          = "out2",
 +        .type          = AVMEDIA_TYPE_AUDIO,
 +        .config_props  = config_output,
 +        .request_frame = request_frame,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_astreamsync = {
 +    .name          = "astreamsync",
 +    .description   = NULL_IF_CONFIG_SMALL("Copy two streams of audio data "
 +                                          "in a configurable order."),
 +    .priv_size     = sizeof(AStreamSyncContext),
 +    .init          = init,
 +    .query_formats = query_formats,
 +    .inputs        = astreamsync_inputs,
 +    .outputs       = astreamsync_outputs,
 +};
Simple merge
index d186aaf,0000000..53bf9e2
mode 100644,000000..100644
--- /dev/null
@@@ -1,1169 -1,0 +1,1163 @@@
-     AVFilterBufferRef *dst_buffer;
 +/*
 + * Copyright (c) 2012 Pavel Koshevoy <pkoshevoy at gmail dot com>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * tempo scaling audio filter -- an implementation of WSOLA algorithm
 + *
 + * Based on MIT licensed yaeAudioTempoFilter.h and yaeAudioFragment.h
 + * from Apprentice Video player by Pavel Koshevoy.
 + * https://sourceforge.net/projects/apprenticevideo/
 + *
 + * An explanation of SOLA algorithm is available at
 + * http://www.surina.net/article/time-and-pitch-scaling.html
 + *
 + * WSOLA is very similar to SOLA, only one major difference exists between
 + * these algorithms.  SOLA shifts audio fragments along the output stream,
 + * where as WSOLA shifts audio fragments along the input stream.
 + *
 + * The advantage of WSOLA algorithm is that the overlap region size is
 + * always the same, therefore the blending function is constant and
 + * can be precomputed.
 + */
 +
 +#include <float.h>
 +#include "libavcodec/avfft.h"
 +#include "libavutil/avassert.h"
 +#include "libavutil/avstring.h"
 +#include "libavutil/channel_layout.h"
 +#include "libavutil/eval.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/samplefmt.h"
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "internal.h"
 +
 +/**
 + * A fragment of audio waveform
 + */
 +typedef struct {
 +    // index of the first sample of this fragment in the overall waveform;
 +    // 0: input sample position
 +    // 1: output sample position
 +    int64_t position[2];
 +
 +    // original packed multi-channel samples:
 +    uint8_t *data;
 +
 +    // number of samples in this fragment:
 +    int nsamples;
 +
 +    // rDFT transform of the down-mixed mono fragment, used for
 +    // fast waveform alignment via correlation in frequency domain:
 +    FFTSample *xdat;
 +} AudioFragment;
 +
 +/**
 + * Filter state machine states
 + */
 +typedef enum {
 +    YAE_LOAD_FRAGMENT,
 +    YAE_ADJUST_POSITION,
 +    YAE_RELOAD_FRAGMENT,
 +    YAE_OUTPUT_OVERLAP_ADD,
 +    YAE_FLUSH_OUTPUT,
 +} FilterState;
 +
 +/**
 + * Filter state machine
 + */
 +typedef struct {
 +    // ring-buffer of input samples, necessary because some times
 +    // input fragment position may be adjusted backwards:
 +    uint8_t *buffer;
 +
 +    // ring-buffer maximum capacity, expressed in sample rate time base:
 +    int ring;
 +
 +    // ring-buffer house keeping:
 +    int size;
 +    int head;
 +    int tail;
 +
 +    // 0: input sample position corresponding to the ring buffer tail
 +    // 1: output sample position
 +    int64_t position[2];
 +
 +    // sample format:
 +    enum AVSampleFormat format;
 +
 +    // number of channels:
 +    int channels;
 +
 +    // row of bytes to skip from one sample to next, across multple channels;
 +    // stride = (number-of-channels * bits-per-sample-per-channel) / 8
 +    int stride;
 +
 +    // fragment window size, power-of-two integer:
 +    int window;
 +
 +    // Hann window coefficients, for feathering
 +    // (blending) the overlapping fragment region:
 +    float *hann;
 +
 +    // tempo scaling factor:
 +    double tempo;
 +
 +    // cumulative alignment drift:
 +    int drift;
 +
 +    // current/previous fragment ring-buffer:
 +    AudioFragment frag[2];
 +
 +    // current fragment index:
 +    uint64_t nfrag;
 +
 +    // current state:
 +    FilterState state;
 +
 +    // for fast correlation calculation in frequency domain:
 +    RDFTContext *real_to_complex;
 +    RDFTContext *complex_to_real;
 +    FFTSample *correlation;
 +
 +    // for managing AVFilterPad.request_frame and AVFilterPad.filter_frame
 +    int request_fulfilled;
-     avfilter_unref_bufferp(&atempo->dst_buffer);
++    AVFrame *dst_buffer;
 +    uint8_t *dst;
 +    uint8_t *dst_end;
 +    uint64_t nsamples_in;
 +    uint64_t nsamples_out;
 +} ATempoContext;
 +
 +/**
 + * Reset filter to initial state, do not deallocate existing local buffers.
 + */
 +static void yae_clear(ATempoContext *atempo)
 +{
 +    atempo->size = 0;
 +    atempo->head = 0;
 +    atempo->tail = 0;
 +
 +    atempo->drift = 0;
 +    atempo->nfrag = 0;
 +    atempo->state = YAE_LOAD_FRAGMENT;
 +
 +    atempo->position[0] = 0;
 +    atempo->position[1] = 0;
 +
 +    atempo->frag[0].position[0] = 0;
 +    atempo->frag[0].position[1] = 0;
 +    atempo->frag[0].nsamples    = 0;
 +
 +    atempo->frag[1].position[0] = 0;
 +    atempo->frag[1].position[1] = 0;
 +    atempo->frag[1].nsamples    = 0;
 +
 +    // shift left position of 1st fragment by half a window
 +    // so that no re-normalization would be required for
 +    // the left half of the 1st fragment:
 +    atempo->frag[0].position[0] = -(int64_t)(atempo->window / 2);
 +    atempo->frag[0].position[1] = -(int64_t)(atempo->window / 2);
 +
-     atempo->dst_buffer->audio->sample_rate = outlink->sample_rate;
-     atempo->dst_buffer->audio->nb_samples  = n_out;
++    av_frame_free(&atempo->dst_buffer);
 +    atempo->dst     = NULL;
 +    atempo->dst_end = NULL;
 +
 +    atempo->request_fulfilled = 0;
 +    atempo->nsamples_in       = 0;
 +    atempo->nsamples_out      = 0;
 +}
 +
 +/**
 + * Reset filter to initial state and deallocate all buffers.
 + */
 +static void yae_release_buffers(ATempoContext *atempo)
 +{
 +    yae_clear(atempo);
 +
 +    av_freep(&atempo->frag[0].data);
 +    av_freep(&atempo->frag[1].data);
 +    av_freep(&atempo->frag[0].xdat);
 +    av_freep(&atempo->frag[1].xdat);
 +
 +    av_freep(&atempo->buffer);
 +    av_freep(&atempo->hann);
 +    av_freep(&atempo->correlation);
 +
 +    av_rdft_end(atempo->real_to_complex);
 +    atempo->real_to_complex = NULL;
 +
 +    av_rdft_end(atempo->complex_to_real);
 +    atempo->complex_to_real = NULL;
 +}
 +
 +/* av_realloc is not aligned enough; fortunately, the data does not need to
 + * be preserved */
 +#define RE_MALLOC_OR_FAIL(field, field_size)                    \
 +    do {                                                        \
 +        av_freep(&field);                                       \
 +        field = av_malloc(field_size);                          \
 +        if (!field) {                                           \
 +            yae_release_buffers(atempo);                        \
 +            return AVERROR(ENOMEM);                             \
 +        }                                                       \
 +    } while (0)
 +
 +/**
 + * Prepare filter for processing audio data of given format,
 + * sample rate and number of channels.
 + */
 +static int yae_reset(ATempoContext *atempo,
 +                     enum AVSampleFormat format,
 +                     int sample_rate,
 +                     int channels)
 +{
 +    const int sample_size = av_get_bytes_per_sample(format);
 +    uint32_t nlevels  = 0;
 +    uint32_t pot;
 +    int i;
 +
 +    atempo->format   = format;
 +    atempo->channels = channels;
 +    atempo->stride   = sample_size * channels;
 +
 +    // pick a segment window size:
 +    atempo->window = sample_rate / 24;
 +
 +    // adjust window size to be a power-of-two integer:
 +    nlevels = av_log2(atempo->window);
 +    pot = 1 << nlevels;
 +    av_assert0(pot <= atempo->window);
 +
 +    if (pot < atempo->window) {
 +        atempo->window = pot * 2;
 +        nlevels++;
 +    }
 +
 +    // initialize audio fragment buffers:
 +    RE_MALLOC_OR_FAIL(atempo->frag[0].data, atempo->window * atempo->stride);
 +    RE_MALLOC_OR_FAIL(atempo->frag[1].data, atempo->window * atempo->stride);
 +    RE_MALLOC_OR_FAIL(atempo->frag[0].xdat, atempo->window * sizeof(FFTComplex));
 +    RE_MALLOC_OR_FAIL(atempo->frag[1].xdat, atempo->window * sizeof(FFTComplex));
 +
 +    // initialize rDFT contexts:
 +    av_rdft_end(atempo->real_to_complex);
 +    atempo->real_to_complex = NULL;
 +
 +    av_rdft_end(atempo->complex_to_real);
 +    atempo->complex_to_real = NULL;
 +
 +    atempo->real_to_complex = av_rdft_init(nlevels + 1, DFT_R2C);
 +    if (!atempo->real_to_complex) {
 +        yae_release_buffers(atempo);
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    atempo->complex_to_real = av_rdft_init(nlevels + 1, IDFT_C2R);
 +    if (!atempo->complex_to_real) {
 +        yae_release_buffers(atempo);
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    RE_MALLOC_OR_FAIL(atempo->correlation, atempo->window * sizeof(FFTComplex));
 +
 +    atempo->ring = atempo->window * 3;
 +    RE_MALLOC_OR_FAIL(atempo->buffer, atempo->ring * atempo->stride);
 +
 +    // initialize the Hann window function:
 +    RE_MALLOC_OR_FAIL(atempo->hann, atempo->window * sizeof(float));
 +
 +    for (i = 0; i < atempo->window; i++) {
 +        double t = (double)i / (double)(atempo->window - 1);
 +        double h = 0.5 * (1.0 - cos(2.0 * M_PI * t));
 +        atempo->hann[i] = (float)h;
 +    }
 +
 +    yae_clear(atempo);
 +    return 0;
 +}
 +
 +static int yae_set_tempo(AVFilterContext *ctx, const char *arg_tempo)
 +{
 +    ATempoContext *atempo = ctx->priv;
 +    char   *tail = NULL;
 +    double tempo = av_strtod(arg_tempo, &tail);
 +
 +    if (tail && *tail) {
 +        av_log(ctx, AV_LOG_ERROR, "Invalid tempo value '%s'\n", arg_tempo);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if (tempo < 0.5 || tempo > 2.0) {
 +        av_log(ctx, AV_LOG_ERROR, "Tempo value %f exceeds [0.5, 2.0] range\n",
 +               tempo);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    atempo->tempo = tempo;
 +    return 0;
 +}
 +
 +inline static AudioFragment *yae_curr_frag(ATempoContext *atempo)
 +{
 +    return &atempo->frag[atempo->nfrag % 2];
 +}
 +
 +inline static AudioFragment *yae_prev_frag(ATempoContext *atempo)
 +{
 +    return &atempo->frag[(atempo->nfrag + 1) % 2];
 +}
 +
 +/**
 + * A helper macro for initializing complex data buffer with scalar data
 + * of a given type.
 + */
 +#define yae_init_xdat(scalar_type, scalar_max)                          \
 +    do {                                                                \
 +        const uint8_t *src_end = src +                                  \
 +            frag->nsamples * atempo->channels * sizeof(scalar_type);    \
 +                                                                        \
 +        FFTSample *xdat = frag->xdat;                                   \
 +        scalar_type tmp;                                                \
 +                                                                        \
 +        if (atempo->channels == 1) {                                    \
 +            for (; src < src_end; xdat++) {                             \
 +                tmp = *(const scalar_type *)src;                        \
 +                src += sizeof(scalar_type);                             \
 +                                                                        \
 +                *xdat = (FFTSample)tmp;                                 \
 +            }                                                           \
 +        } else {                                                        \
 +            FFTSample s, max, ti, si;                                   \
 +            int i;                                                      \
 +                                                                        \
 +            for (; src < src_end; xdat++) {                             \
 +                tmp = *(const scalar_type *)src;                        \
 +                src += sizeof(scalar_type);                             \
 +                                                                        \
 +                max = (FFTSample)tmp;                                   \
 +                s = FFMIN((FFTSample)scalar_max,                        \
 +                          (FFTSample)fabsf(max));                       \
 +                                                                        \
 +                for (i = 1; i < atempo->channels; i++) {                \
 +                    tmp = *(const scalar_type *)src;                    \
 +                    src += sizeof(scalar_type);                         \
 +                                                                        \
 +                    ti = (FFTSample)tmp;                                \
 +                    si = FFMIN((FFTSample)scalar_max,                   \
 +                               (FFTSample)fabsf(ti));                   \
 +                                                                        \
 +                    if (s < si) {                                       \
 +                        s   = si;                                       \
 +                        max = ti;                                       \
 +                    }                                                   \
 +                }                                                       \
 +                                                                        \
 +                *xdat = max;                                            \
 +            }                                                           \
 +        }                                                               \
 +    } while (0)
 +
 +/**
 + * Initialize complex data buffer of a given audio fragment
 + * with down-mixed mono data of appropriate scalar type.
 + */
 +static void yae_downmix(ATempoContext *atempo, AudioFragment *frag)
 +{
 +    // shortcuts:
 +    const uint8_t *src = frag->data;
 +
 +    // init complex data buffer used for FFT and Correlation:
 +    memset(frag->xdat, 0, sizeof(FFTComplex) * atempo->window);
 +
 +    if (atempo->format == AV_SAMPLE_FMT_U8) {
 +        yae_init_xdat(uint8_t, 127);
 +    } else if (atempo->format == AV_SAMPLE_FMT_S16) {
 +        yae_init_xdat(int16_t, 32767);
 +    } else if (atempo->format == AV_SAMPLE_FMT_S32) {
 +        yae_init_xdat(int, 2147483647);
 +    } else if (atempo->format == AV_SAMPLE_FMT_FLT) {
 +        yae_init_xdat(float, 1);
 +    } else if (atempo->format == AV_SAMPLE_FMT_DBL) {
 +        yae_init_xdat(double, 1);
 +    }
 +}
 +
 +/**
 + * Populate the internal data buffer on as-needed basis.
 + *
 + * @return
 + *   0 if requested data was already available or was successfully loaded,
 + *   AVERROR(EAGAIN) if more input data is required.
 + */
 +static int yae_load_data(ATempoContext *atempo,
 +                         const uint8_t **src_ref,
 +                         const uint8_t *src_end,
 +                         int64_t stop_here)
 +{
 +    // shortcut:
 +    const uint8_t *src = *src_ref;
 +    const int read_size = stop_here - atempo->position[0];
 +
 +    if (stop_here <= atempo->position[0]) {
 +        return 0;
 +    }
 +
 +    // samples are not expected to be skipped:
 +    av_assert0(read_size <= atempo->ring);
 +
 +    while (atempo->position[0] < stop_here && src < src_end) {
 +        int src_samples = (src_end - src) / atempo->stride;
 +
 +        // load data piece-wise, in order to avoid complicating the logic:
 +        int nsamples = FFMIN(read_size, src_samples);
 +        int na;
 +        int nb;
 +
 +        nsamples = FFMIN(nsamples, atempo->ring);
 +        na = FFMIN(nsamples, atempo->ring - atempo->tail);
 +        nb = FFMIN(nsamples - na, atempo->ring);
 +
 +        if (na) {
 +            uint8_t *a = atempo->buffer + atempo->tail * atempo->stride;
 +            memcpy(a, src, na * atempo->stride);
 +
 +            src += na * atempo->stride;
 +            atempo->position[0] += na;
 +
 +            atempo->size = FFMIN(atempo->size + na, atempo->ring);
 +            atempo->tail = (atempo->tail + na) % atempo->ring;
 +            atempo->head =
 +                atempo->size < atempo->ring ?
 +                atempo->tail - atempo->size :
 +                atempo->tail;
 +        }
 +
 +        if (nb) {
 +            uint8_t *b = atempo->buffer;
 +            memcpy(b, src, nb * atempo->stride);
 +
 +            src += nb * atempo->stride;
 +            atempo->position[0] += nb;
 +
 +            atempo->size = FFMIN(atempo->size + nb, atempo->ring);
 +            atempo->tail = (atempo->tail + nb) % atempo->ring;
 +            atempo->head =
 +                atempo->size < atempo->ring ?
 +                atempo->tail - atempo->size :
 +                atempo->tail;
 +        }
 +    }
 +
 +    // pass back the updated source buffer pointer:
 +    *src_ref = src;
 +
 +    // sanity check:
 +    av_assert0(atempo->position[0] <= stop_here);
 +
 +    return atempo->position[0] == stop_here ? 0 : AVERROR(EAGAIN);
 +}
 +
 +/**
 + * Populate current audio fragment data buffer.
 + *
 + * @return
 + *   0 when the fragment is ready,
 + *   AVERROR(EAGAIN) if more input data is required.
 + */
 +static int yae_load_frag(ATempoContext *atempo,
 +                         const uint8_t **src_ref,
 +                         const uint8_t *src_end)
 +{
 +    // shortcuts:
 +    AudioFragment *frag = yae_curr_frag(atempo);
 +    uint8_t *dst;
 +    int64_t missing, start, zeros;
 +    uint32_t nsamples;
 +    const uint8_t *a, *b;
 +    int i0, i1, n0, n1, na, nb;
 +
 +    int64_t stop_here = frag->position[0] + atempo->window;
 +    if (src_ref && yae_load_data(atempo, src_ref, src_end, stop_here) != 0) {
 +        return AVERROR(EAGAIN);
 +    }
 +
 +    // calculate the number of samples we don't have:
 +    missing =
 +        stop_here > atempo->position[0] ?
 +        stop_here - atempo->position[0] : 0;
 +
 +    nsamples =
 +        missing < (int64_t)atempo->window ?
 +        (uint32_t)(atempo->window - missing) : 0;
 +
 +    // setup the output buffer:
 +    frag->nsamples = nsamples;
 +    dst = frag->data;
 +
 +    start = atempo->position[0] - atempo->size;
 +    zeros = 0;
 +
 +    if (frag->position[0] < start) {
 +        // what we don't have we substitute with zeros:
 +        zeros = FFMIN(start - frag->position[0], (int64_t)nsamples);
 +        av_assert0(zeros != nsamples);
 +
 +        memset(dst, 0, zeros * atempo->stride);
 +        dst += zeros * atempo->stride;
 +    }
 +
 +    if (zeros == nsamples) {
 +        return 0;
 +    }
 +
 +    // get the remaining data from the ring buffer:
 +    na = (atempo->head < atempo->tail ?
 +          atempo->tail - atempo->head :
 +          atempo->ring - atempo->head);
 +
 +    nb = atempo->head < atempo->tail ? 0 : atempo->tail;
 +
 +    // sanity check:
 +    av_assert0(nsamples <= zeros + na + nb);
 +
 +    a = atempo->buffer + atempo->head * atempo->stride;
 +    b = atempo->buffer;
 +
 +    i0 = frag->position[0] + zeros - start;
 +    i1 = i0 < na ? 0 : i0 - na;
 +
 +    n0 = i0 < na ? FFMIN(na - i0, (int)(nsamples - zeros)) : 0;
 +    n1 = nsamples - zeros - n0;
 +
 +    if (n0) {
 +        memcpy(dst, a + i0 * atempo->stride, n0 * atempo->stride);
 +        dst += n0 * atempo->stride;
 +    }
 +
 +    if (n1) {
 +        memcpy(dst, b + i1 * atempo->stride, n1 * atempo->stride);
 +    }
 +
 +    return 0;
 +}
 +
 +/**
 + * Prepare for loading next audio fragment.
 + */
 +static void yae_advance_to_next_frag(ATempoContext *atempo)
 +{
 +    const double fragment_step = atempo->tempo * (double)(atempo->window / 2);
 +
 +    const AudioFragment *prev;
 +    AudioFragment       *frag;
 +
 +    atempo->nfrag++;
 +    prev = yae_prev_frag(atempo);
 +    frag = yae_curr_frag(atempo);
 +
 +    frag->position[0] = prev->position[0] + (int64_t)fragment_step;
 +    frag->position[1] = prev->position[1] + atempo->window / 2;
 +    frag->nsamples    = 0;
 +}
 +
 +/**
 + * Calculate cross-correlation via rDFT.
 + *
 + * Multiply two vectors of complex numbers (result of real_to_complex rDFT)
 + * and transform back via complex_to_real rDFT.
 + */
 +static void yae_xcorr_via_rdft(FFTSample *xcorr,
 +                               RDFTContext *complex_to_real,
 +                               const FFTComplex *xa,
 +                               const FFTComplex *xb,
 +                               const int window)
 +{
 +    FFTComplex *xc = (FFTComplex *)xcorr;
 +    int i;
 +
 +    // NOTE: first element requires special care -- Given Y = rDFT(X),
 +    // Im(Y[0]) and Im(Y[N/2]) are always zero, therefore av_rdft_calc
 +    // stores Re(Y[N/2]) in place of Im(Y[0]).
 +
 +    xc->re = xa->re * xb->re;
 +    xc->im = xa->im * xb->im;
 +    xa++;
 +    xb++;
 +    xc++;
 +
 +    for (i = 1; i < window; i++, xa++, xb++, xc++) {
 +        xc->re = (xa->re * xb->re + xa->im * xb->im);
 +        xc->im = (xa->im * xb->re - xa->re * xb->im);
 +    }
 +
 +    // apply inverse rDFT:
 +    av_rdft_calc(complex_to_real, xcorr);
 +}
 +
 +/**
 + * Calculate alignment offset for given fragment
 + * relative to the previous fragment.
 + *
 + * @return alignment offset of current fragment relative to previous.
 + */
 +static int yae_align(AudioFragment *frag,
 +                     const AudioFragment *prev,
 +                     const int window,
 +                     const int delta_max,
 +                     const int drift,
 +                     FFTSample *correlation,
 +                     RDFTContext *complex_to_real)
 +{
 +    int       best_offset = -drift;
 +    FFTSample best_metric = -FLT_MAX;
 +    FFTSample *xcorr;
 +
 +    int i0;
 +    int i1;
 +    int i;
 +
 +    yae_xcorr_via_rdft(correlation,
 +                       complex_to_real,
 +                       (const FFTComplex *)prev->xdat,
 +                       (const FFTComplex *)frag->xdat,
 +                       window);
 +
 +    // identify search window boundaries:
 +    i0 = FFMAX(window / 2 - delta_max - drift, 0);
 +    i0 = FFMIN(i0, window);
 +
 +    i1 = FFMIN(window / 2 + delta_max - drift, window - window / 16);
 +    i1 = FFMAX(i1, 0);
 +
 +    // identify cross-correlation peaks within search window:
 +    xcorr = correlation + i0;
 +
 +    for (i = i0; i < i1; i++, xcorr++) {
 +        FFTSample metric = *xcorr;
 +
 +        // normalize:
 +        FFTSample drifti = (FFTSample)(drift + i);
 +        metric *= drifti * (FFTSample)(i - i0) * (FFTSample)(i1 - i);
 +
 +        if (metric > best_metric) {
 +            best_metric = metric;
 +            best_offset = i - window / 2;
 +        }
 +    }
 +
 +    return best_offset;
 +}
 +
 +/**
 + * Adjust current fragment position for better alignment
 + * with previous fragment.
 + *
 + * @return alignment correction.
 + */
 +static int yae_adjust_position(ATempoContext *atempo)
 +{
 +    const AudioFragment *prev = yae_prev_frag(atempo);
 +    AudioFragment       *frag = yae_curr_frag(atempo);
 +
 +    const int delta_max  = atempo->window / 2;
 +    const int correction = yae_align(frag,
 +                                     prev,
 +                                     atempo->window,
 +                                     delta_max,
 +                                     atempo->drift,
 +                                     atempo->correlation,
 +                                     atempo->complex_to_real);
 +
 +    if (correction) {
 +        // adjust fragment position:
 +        frag->position[0] -= correction;
 +
 +        // clear so that the fragment can be reloaded:
 +        frag->nsamples = 0;
 +
 +        // update cumulative correction drift counter:
 +        atempo->drift += correction;
 +    }
 +
 +    return correction;
 +}
 +
 +/**
 + * A helper macro for blending the overlap region of previous
 + * and current audio fragment.
 + */
 +#define yae_blend(scalar_type)                                          \
 +    do {                                                                \
 +        const scalar_type *aaa = (const scalar_type *)a;                \
 +        const scalar_type *bbb = (const scalar_type *)b;                \
 +                                                                        \
 +        scalar_type *out     = (scalar_type *)dst;                      \
 +        scalar_type *out_end = (scalar_type *)dst_end;                  \
 +        int64_t i;                                                      \
 +                                                                        \
 +        for (i = 0; i < overlap && out < out_end;                       \
 +             i++, atempo->position[1]++, wa++, wb++) {                  \
 +            float w0 = *wa;                                             \
 +            float w1 = *wb;                                             \
 +            int j;                                                      \
 +                                                                        \
 +            for (j = 0; j < atempo->channels;                           \
 +                 j++, aaa++, bbb++, out++) {                            \
 +                float t0 = (float)*aaa;                                 \
 +                float t1 = (float)*bbb;                                 \
 +                                                                        \
 +                *out =                                                  \
 +                    frag->position[0] + i < 0 ?                         \
 +                    *aaa :                                              \
 +                    (scalar_type)(t0 * w0 + t1 * w1);                   \
 +            }                                                           \
 +        }                                                               \
 +        dst = (uint8_t *)out;                                           \
 +    } while (0)
 +
 +/**
 + * Blend the overlap region of previous and current audio fragment
 + * and output the results to the given destination buffer.
 + *
 + * @return
 + *   0 if the overlap region was completely stored in the dst buffer,
 + *   AVERROR(EAGAIN) if more destination buffer space is required.
 + */
 +static int yae_overlap_add(ATempoContext *atempo,
 +                           uint8_t **dst_ref,
 +                           uint8_t *dst_end)
 +{
 +    // shortcuts:
 +    const AudioFragment *prev = yae_prev_frag(atempo);
 +    const AudioFragment *frag = yae_curr_frag(atempo);
 +
 +    const int64_t start_here = FFMAX(atempo->position[1],
 +                                     frag->position[1]);
 +
 +    const int64_t stop_here = FFMIN(prev->position[1] + prev->nsamples,
 +                                    frag->position[1] + frag->nsamples);
 +
 +    const int64_t overlap = stop_here - start_here;
 +
 +    const int64_t ia = start_here - prev->position[1];
 +    const int64_t ib = start_here - frag->position[1];
 +
 +    const float *wa = atempo->hann + ia;
 +    const float *wb = atempo->hann + ib;
 +
 +    const uint8_t *a = prev->data + ia * atempo->stride;
 +    const uint8_t *b = frag->data + ib * atempo->stride;
 +
 +    uint8_t *dst = *dst_ref;
 +
 +    av_assert0(start_here <= stop_here &&
 +               frag->position[1] <= start_here &&
 +               overlap <= frag->nsamples);
 +
 +    if (atempo->format == AV_SAMPLE_FMT_U8) {
 +        yae_blend(uint8_t);
 +    } else if (atempo->format == AV_SAMPLE_FMT_S16) {
 +        yae_blend(int16_t);
 +    } else if (atempo->format == AV_SAMPLE_FMT_S32) {
 +        yae_blend(int);
 +    } else if (atempo->format == AV_SAMPLE_FMT_FLT) {
 +        yae_blend(float);
 +    } else if (atempo->format == AV_SAMPLE_FMT_DBL) {
 +        yae_blend(double);
 +    }
 +
 +    // pass-back the updated destination buffer pointer:
 +    *dst_ref = dst;
 +
 +    return atempo->position[1] == stop_here ? 0 : AVERROR(EAGAIN);
 +}
 +
 +/**
 + * Feed as much data to the filter as it is able to consume
 + * and receive as much processed data in the destination buffer
 + * as it is able to produce or store.
 + */
 +static void
 +yae_apply(ATempoContext *atempo,
 +          const uint8_t **src_ref,
 +          const uint8_t *src_end,
 +          uint8_t **dst_ref,
 +          uint8_t *dst_end)
 +{
 +    while (1) {
 +        if (atempo->state == YAE_LOAD_FRAGMENT) {
 +            // load additional data for the current fragment:
 +            if (yae_load_frag(atempo, src_ref, src_end) != 0) {
 +                break;
 +            }
 +
 +            // down-mix to mono:
 +            yae_downmix(atempo, yae_curr_frag(atempo));
 +
 +            // apply rDFT:
 +            av_rdft_calc(atempo->real_to_complex, yae_curr_frag(atempo)->xdat);
 +
 +            // must load the second fragment before alignment can start:
 +            if (!atempo->nfrag) {
 +                yae_advance_to_next_frag(atempo);
 +                continue;
 +            }
 +
 +            atempo->state = YAE_ADJUST_POSITION;
 +        }
 +
 +        if (atempo->state == YAE_ADJUST_POSITION) {
 +            // adjust position for better alignment:
 +            if (yae_adjust_position(atempo)) {
 +                // reload the fragment at the corrected position, so that the
 +                // Hann window blending would not require normalization:
 +                atempo->state = YAE_RELOAD_FRAGMENT;
 +            } else {
 +                atempo->state = YAE_OUTPUT_OVERLAP_ADD;
 +            }
 +        }
 +
 +        if (atempo->state == YAE_RELOAD_FRAGMENT) {
 +            // load additional data if necessary due to position adjustment:
 +            if (yae_load_frag(atempo, src_ref, src_end) != 0) {
 +                break;
 +            }
 +
 +            // down-mix to mono:
 +            yae_downmix(atempo, yae_curr_frag(atempo));
 +
 +            // apply rDFT:
 +            av_rdft_calc(atempo->real_to_complex, yae_curr_frag(atempo)->xdat);
 +
 +            atempo->state = YAE_OUTPUT_OVERLAP_ADD;
 +        }
 +
 +        if (atempo->state == YAE_OUTPUT_OVERLAP_ADD) {
 +            // overlap-add and output the result:
 +            if (yae_overlap_add(atempo, dst_ref, dst_end) != 0) {
 +                break;
 +            }
 +
 +            // advance to the next fragment, repeat:
 +            yae_advance_to_next_frag(atempo);
 +            atempo->state = YAE_LOAD_FRAGMENT;
 +        }
 +    }
 +}
 +
 +/**
 + * Flush any buffered data from the filter.
 + *
 + * @return
 + *   0 if all data was completely stored in the dst buffer,
 + *   AVERROR(EAGAIN) if more destination buffer space is required.
 + */
 +static int yae_flush(ATempoContext *atempo,
 +                     uint8_t **dst_ref,
 +                     uint8_t *dst_end)
 +{
 +    AudioFragment *frag = yae_curr_frag(atempo);
 +    int64_t overlap_end;
 +    int64_t start_here;
 +    int64_t stop_here;
 +    int64_t offset;
 +
 +    const uint8_t *src;
 +    uint8_t *dst;
 +
 +    int src_size;
 +    int dst_size;
 +    int nbytes;
 +
 +    atempo->state = YAE_FLUSH_OUTPUT;
 +
 +    if (atempo->position[0] == frag->position[0] + frag->nsamples &&
 +        atempo->position[1] == frag->position[1] + frag->nsamples) {
 +        // the current fragment is already flushed:
 +        return 0;
 +    }
 +
 +    if (frag->position[0] + frag->nsamples < atempo->position[0]) {
 +        // finish loading the current (possibly partial) fragment:
 +        yae_load_frag(atempo, NULL, NULL);
 +
 +        if (atempo->nfrag) {
 +            // down-mix to mono:
 +            yae_downmix(atempo, frag);
 +
 +            // apply rDFT:
 +            av_rdft_calc(atempo->real_to_complex, frag->xdat);
 +
 +            // align current fragment to previous fragment:
 +            if (yae_adjust_position(atempo)) {
 +                // reload the current fragment due to adjusted position:
 +                yae_load_frag(atempo, NULL, NULL);
 +            }
 +        }
 +    }
 +
 +    // flush the overlap region:
 +    overlap_end = frag->position[1] + FFMIN(atempo->window / 2,
 +                                            frag->nsamples);
 +
 +    while (atempo->position[1] < overlap_end) {
 +        if (yae_overlap_add(atempo, dst_ref, dst_end) != 0) {
 +            return AVERROR(EAGAIN);
 +        }
 +    }
 +
 +    // flush the remaininder of the current fragment:
 +    start_here = FFMAX(atempo->position[1], overlap_end);
 +    stop_here  = frag->position[1] + frag->nsamples;
 +    offset     = start_here - frag->position[1];
 +    av_assert0(start_here <= stop_here && frag->position[1] <= start_here);
 +
 +    src = frag->data + offset * atempo->stride;
 +    dst = (uint8_t *)*dst_ref;
 +
 +    src_size = (int)(stop_here - start_here) * atempo->stride;
 +    dst_size = dst_end - dst;
 +    nbytes = FFMIN(src_size, dst_size);
 +
 +    memcpy(dst, src, nbytes);
 +    dst += nbytes;
 +
 +    atempo->position[1] += (nbytes / atempo->stride);
 +
 +    // pass-back the updated destination buffer pointer:
 +    *dst_ref = (uint8_t *)dst;
 +
 +    return atempo->position[1] == stop_here ? 0 : AVERROR(EAGAIN);
 +}
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    ATempoContext *atempo = ctx->priv;
 +
 +    // NOTE: this assumes that the caller has memset ctx->priv to 0:
 +    atempo->format = AV_SAMPLE_FMT_NONE;
 +    atempo->tempo  = 1.0;
 +    atempo->state  = YAE_LOAD_FRAGMENT;
 +
 +    return args ? yae_set_tempo(ctx, args) : 0;
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    ATempoContext *atempo = ctx->priv;
 +    yae_release_buffers(atempo);
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    AVFilterChannelLayouts *layouts = NULL;
 +    AVFilterFormats        *formats = NULL;
 +
 +    // WSOLA necessitates an internal sliding window ring buffer
 +    // for incoming audio stream.
 +    //
 +    // Planar sample formats are too cumbersome to store in a ring buffer,
 +    // therefore planar sample formats are not supported.
 +    //
 +    static const enum AVSampleFormat sample_fmts[] = {
 +        AV_SAMPLE_FMT_U8,
 +        AV_SAMPLE_FMT_S16,
 +        AV_SAMPLE_FMT_S32,
 +        AV_SAMPLE_FMT_FLT,
 +        AV_SAMPLE_FMT_DBL,
 +        AV_SAMPLE_FMT_NONE
 +    };
 +
 +    layouts = ff_all_channel_layouts();
 +    if (!layouts) {
 +        return AVERROR(ENOMEM);
 +    }
 +    ff_set_common_channel_layouts(ctx, layouts);
 +
 +    formats = ff_make_format_list(sample_fmts);
 +    if (!formats) {
 +        return AVERROR(ENOMEM);
 +    }
 +    ff_set_common_formats(ctx, formats);
 +
 +    formats = ff_all_samplerates();
 +    if (!formats) {
 +        return AVERROR(ENOMEM);
 +    }
 +    ff_set_common_samplerates(ctx, formats);
 +
 +    return 0;
 +}
 +
 +static int config_props(AVFilterLink *inlink)
 +{
 +    AVFilterContext  *ctx = inlink->dst;
 +    ATempoContext *atempo = ctx->priv;
 +
 +    enum AVSampleFormat format = inlink->format;
 +    int sample_rate = (int)inlink->sample_rate;
 +    int channels = av_get_channel_layout_nb_channels(inlink->channel_layout);
 +
 +    return yae_reset(atempo, format, sample_rate, channels);
 +}
 +
 +static void push_samples(ATempoContext *atempo,
 +                         AVFilterLink *outlink,
 +                         int n_out)
 +{
- static int filter_frame(AVFilterLink *inlink,
-                            AVFilterBufferRef *src_buffer)
++    atempo->dst_buffer->sample_rate = outlink->sample_rate;
++    atempo->dst_buffer->nb_samples  = n_out;
 +
 +    // adjust the PTS:
 +    atempo->dst_buffer->pts =
 +        av_rescale_q(atempo->nsamples_out,
 +                     (AVRational){ 1, outlink->sample_rate },
 +                     outlink->time_base);
 +
 +    ff_filter_frame(outlink, atempo->dst_buffer);
 +    atempo->dst_buffer = NULL;
 +    atempo->dst        = NULL;
 +    atempo->dst_end    = NULL;
 +
 +    atempo->nsamples_out += n_out;
 +}
 +
-     int n_in = src_buffer->audio->nb_samples;
++static int filter_frame(AVFilterLink *inlink, AVFrame *src_buffer)
 +{
 +    AVFilterContext  *ctx = inlink->dst;
 +    ATempoContext *atempo = ctx->priv;
 +    AVFilterLink *outlink = ctx->outputs[0];
 +
-             atempo->dst_buffer = ff_get_audio_buffer(outlink,
-                                                      AV_PERM_WRITE,
-                                                      n_out);
-             avfilter_copy_buffer_ref_props(atempo->dst_buffer, src_buffer);
++    int n_in = src_buffer->nb_samples;
 +    int n_out = (int)(0.5 + ((double)n_in) / atempo->tempo);
 +
 +    const uint8_t *src = src_buffer->data[0];
 +    const uint8_t *src_end = src + n_in * atempo->stride;
 +
 +    while (src < src_end) {
 +        if (!atempo->dst_buffer) {
-     avfilter_unref_bufferp(&src_buffer);
++            atempo->dst_buffer = ff_get_audio_buffer(outlink, n_out);
++            av_frame_copy_props(atempo->dst_buffer, src_buffer);
 +
 +            atempo->dst = atempo->dst_buffer->data[0];
 +            atempo->dst_end = atempo->dst + n_out * atempo->stride;
 +        }
 +
 +        yae_apply(atempo, &src, src_end, &atempo->dst, atempo->dst_end);
 +
 +        if (atempo->dst == atempo->dst_end) {
 +            push_samples(atempo, outlink, n_out);
 +            atempo->request_fulfilled = 1;
 +        }
 +    }
 +
 +    atempo->nsamples_in += n_in;
-                 atempo->dst_buffer = ff_get_audio_buffer(outlink,
-                                                          AV_PERM_WRITE,
-                                                          n_max);
++    av_frame_free(&src_buffer);
 +    return 0;
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext  *ctx = outlink->src;
 +    ATempoContext *atempo = ctx->priv;
 +    int ret;
 +
 +    atempo->request_fulfilled = 0;
 +    do {
 +        ret = ff_request_frame(ctx->inputs[0]);
 +    }
 +    while (!atempo->request_fulfilled && ret >= 0);
 +
 +    if (ret == AVERROR_EOF) {
 +        // flush the filter:
 +        int n_max = atempo->ring;
 +        int n_out;
 +        int err = AVERROR(EAGAIN);
 +
 +        while (err == AVERROR(EAGAIN)) {
 +            if (!atempo->dst_buffer) {
-         avfilter_unref_bufferp(&atempo->dst_buffer);
++                atempo->dst_buffer = ff_get_audio_buffer(outlink, n_max);
 +
 +                atempo->dst = atempo->dst_buffer->data[0];
 +                atempo->dst_end = atempo->dst + n_max * atempo->stride;
 +            }
 +
 +            err = yae_flush(atempo, &atempo->dst, atempo->dst_end);
 +
 +            n_out = ((atempo->dst - atempo->dst_buffer->data[0]) /
 +                     atempo->stride);
 +
 +            if (n_out) {
 +                push_samples(atempo, outlink, n_out);
 +            }
 +        }
 +
-         .min_perms    = AV_PERM_READ,
++        av_frame_free(&atempo->dst_buffer);
 +        atempo->dst     = NULL;
 +        atempo->dst_end = NULL;
 +
 +        return AVERROR_EOF;
 +    }
 +
 +    return ret;
 +}
 +
 +static int process_command(AVFilterContext *ctx,
 +                           const char *cmd,
 +                           const char *arg,
 +                           char *res,
 +                           int res_len,
 +                           int flags)
 +{
 +    return !strcmp(cmd, "tempo") ? yae_set_tempo(ctx, arg) : AVERROR(ENOSYS);
 +}
 +
 +static const AVFilterPad atempo_inputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +        .config_props = config_props,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad atempo_outputs[] = {
 +    {
 +        .name          = "default",
 +        .request_frame = request_frame,
 +        .type          = AVMEDIA_TYPE_AUDIO,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_atempo = {
 +    .name            = "atempo",
 +    .description     = NULL_IF_CONFIG_SMALL("Adjust audio tempo."),
 +    .init            = init,
 +    .uninit          = uninit,
 +    .query_formats   = query_formats,
 +    .process_command = process_command,
 +    .priv_size       = sizeof(ATempoContext),
 +    .inputs          = atempo_inputs,
 +    .outputs         = atempo_outputs,
 +};
index cae3e02,0000000..6384090
mode 100644,000000..100644
--- /dev/null
@@@ -1,627 -1,0 +1,627 @@@
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
 +/*
 + * Copyright (c) 2013 Paul B Mahol
 + * Copyright (c) 2006-2008 Rob Sykes <robs@users.sourceforge.net>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/*
 + * 2-pole filters designed by Robert Bristow-Johnson <rbj@audioimagination.com>
 + *   see http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
 + *
 + * 1-pole filters based on code (c) 2000 Chris Bagwell <cbagwell@sprynet.com>
 + *   Algorithms: Recursive single pole low/high pass filter
 + *   Reference: The Scientist and Engineer's Guide to Digital Signal Processing
 + *
 + *   low-pass: output[N] = input[N] * A + output[N-1] * B
 + *     X = exp(-2.0 * pi * Fc)
 + *     A = 1 - X
 + *     B = X
 + *     Fc = cutoff freq / sample rate
 + *
 + *     Mimics an RC low-pass filter:
 + *
 + *     ---/\/\/\/\----------->
 + *                   |
 + *                  --- C
 + *                  ---
 + *                   |
 + *                   |
 + *                   V
 + *
 + *   high-pass: output[N] = A0 * input[N] + A1 * input[N-1] + B1 * output[N-1]
 + *     X  = exp(-2.0 * pi * Fc)
 + *     A0 = (1 + X) / 2
 + *     A1 = -(1 + X) / 2
 + *     B1 = X
 + *     Fc = cutoff freq / sample rate
 + *
 + *     Mimics an RC high-pass filter:
 + *
 + *         || C
 + *     ----||--------->
 + *         ||    |
 + *               <
 + *               > R
 + *               <
 + *               |
 + *               V
 + */
 +
 +#include "libavutil/opt.h"
 +#include "libavutil/avassert.h"
 +#include "audio.h"
 +#include "avfilter.h"
 +#include "internal.h"
 +
 +enum FilterType {
 +    biquad,
 +    equalizer,
 +    bass,
 +    treble,
 +    band,
 +    bandpass,
 +    bandreject,
 +    allpass,
 +    highpass,
 +    lowpass,
 +};
 +
 +enum WidthType {
 +    NONE,
 +    HZ,
 +    OCTAVE,
 +    QFACTOR,
 +    SLOPE,
 +};
 +
 +typedef struct ChanCache {
 +    double i1, i2;
 +    double o1, o2;
 +} ChanCache;
 +
 +typedef struct {
 +    const AVClass *class;
 +
 +    enum FilterType filter_type;
 +    enum WidthType width_type;
 +    int poles;
 +    int csg;
 +
 +    double gain;
 +    double frequency;
 +    double width;
 +
 +    double a0, a1, a2;
 +    double b0, b1, b2;
 +
 +    ChanCache *cache;
 +
 +    void (*filter)(const void *ibuf, void *obuf, int len,
 +                   double *i1, double *i2, double *o1, double *o2,
 +                   double b0, double b1, double b2, double a1, double a2);
 +} BiquadsContext;
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    BiquadsContext *p = ctx->priv;
 +    int ret;
 +
 +    av_opt_set_defaults(p);
 +
 +    if ((ret = av_set_options_string(p, args, "=", ":")) < 0)
 +        return ret;
 +
 +    if (p->filter_type != biquad) {
 +        if (p->frequency <= 0 || p->width <= 0) {
 +            av_log(ctx, AV_LOG_ERROR, "Invalid frequency %f and/or width %f <= 0\n",
 +                   p->frequency, p->width);
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    AVFilterFormats *formats;
 +    AVFilterChannelLayouts *layouts;
 +    static const enum AVSampleFormat sample_fmts[] = {
 +        AV_SAMPLE_FMT_S16P,
 +        AV_SAMPLE_FMT_S32P,
 +        AV_SAMPLE_FMT_FLTP,
 +        AV_SAMPLE_FMT_DBLP,
 +        AV_SAMPLE_FMT_NONE
 +    };
 +
 +    layouts = ff_all_channel_layouts();
 +    if (!layouts)
 +        return AVERROR(ENOMEM);
 +    ff_set_common_channel_layouts(ctx, layouts);
 +
 +    formats = ff_make_format_list(sample_fmts);
 +    if (!formats)
 +        return AVERROR(ENOMEM);
 +    ff_set_common_formats(ctx, formats);
 +
 +    formats = ff_all_samplerates();
 +    if (!formats)
 +        return AVERROR(ENOMEM);
 +    ff_set_common_samplerates(ctx, formats);
 +
 +    return 0;
 +}
 +
 +#define BIQUAD_FILTER(name, type, min, max)                                   \
 +static void biquad_## name (const void *input, void *output, int len,         \
 +                            double *in1, double *in2,                         \
 +                            double *out1, double *out2,                       \
 +                            double b0, double b1, double b2,                  \
 +                            double a1, double a2)                             \
 +{                                                                             \
 +    const type *ibuf = input;                                                 \
 +    type *obuf = output;                                                      \
 +    double i1 = *in1;                                                         \
 +    double i2 = *in2;                                                         \
 +    double o1 = *out1;                                                        \
 +    double o2 = *out2;                                                        \
 +    int i;                                                                    \
 +    a1 = -a1;                                                                 \
 +    a2 = -a2;                                                                 \
 +                                                                              \
 +    for (i = 0; i+1 < len; i++) {                                             \
 +        o2 = i2 * b2 + i1 * b1 + ibuf[i] * b0 + o2 * a2 + o1 * a1;            \
 +        i2 = ibuf[i];                                                         \
 +        if (o2 < min) {                                                       \
 +            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 +            obuf[i] = min;                                                    \
 +        } else if (o2 > max) {                                                \
 +            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 +            obuf[i] = max;                                                    \
 +        } else {                                                              \
 +            obuf[i] = o2;                                                     \
 +        }                                                                     \
 +        i++;                                                                  \
 +        o1 = i1 * b2 + i2 * b1 + ibuf[i] * b0 + o1 * a2 + o2 * a1;            \
 +        i1 = ibuf[i];                                                         \
 +        if (o1 < min) {                                                       \
 +            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 +            obuf[i] = min;                                                    \
 +        } else if (o1 > max) {                                                \
 +            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 +            obuf[i] = max;                                                    \
 +        } else {                                                              \
 +            obuf[i] = o1;                                                     \
 +        }                                                                     \
 +    }                                                                         \
 +    if (i < len) {                                                            \
 +        double o0 = ibuf[i] * b0 + i1 * b1 + i2 * b2 + o1 * a1 + o2 * a2;     \
 +        i2 = i1;                                                              \
 +        i1 = ibuf[i];                                                         \
 +        o2 = o1;                                                              \
 +        o1 = o0;                                                              \
 +        if (o0 < min) {                                                       \
 +            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 +            obuf[i] = min;                                                    \
 +        } else if (o0 > max) {                                                \
 +            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 +            obuf[i] = max;                                                    \
 +        } else {                                                              \
 +            obuf[i] = o0;                                                     \
 +        }                                                                     \
 +    }                                                                         \
 +    *in1  = i1;                                                               \
 +    *in2  = i2;                                                               \
 +    *out1 = o1;                                                               \
 +    *out2 = o2;                                                               \
 +}
 +
 +BIQUAD_FILTER(s16, int16_t, INT16_MIN, INT16_MAX)
 +BIQUAD_FILTER(s32, int32_t, INT32_MIN, INT32_MAX)
 +BIQUAD_FILTER(flt, float,   -1., 1.)
 +BIQUAD_FILTER(dbl, double,  -1., 1.)
 +
 +static int config_output(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx    = outlink->src;
 +    BiquadsContext *p       = ctx->priv;
 +    AVFilterLink *inlink    = ctx->inputs[0];
 +    double A = exp(p->gain / 40 * log(10.));
 +    double w0 = 2 * M_PI * p->frequency / inlink->sample_rate;
 +    double alpha;
 +
 +    if (w0 > M_PI) {
 +        av_log(ctx, AV_LOG_ERROR,
 +               "Invalid frequency %f. Frequency must be less than half the sample-rate %d.\n",
 +               p->frequency, inlink->sample_rate);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    switch (p->width_type) {
 +    case NONE:
 +        alpha = 0.0;
 +        break;
 +    case HZ:
 +        alpha = sin(w0) / (2 * p->frequency / p->width);
 +        break;
 +    case OCTAVE:
 +        alpha = sin(w0) * sinh(log(2.) / 2 * p->width * w0 / sin(w0));
 +        break;
 +    case QFACTOR:
 +        alpha = sin(w0) / (2 * p->width);
 +        break;
 +    case SLOPE:
 +        alpha = sin(w0) / 2 * sqrt((A + 1 / A) * (1 / p->width - 1) + 2);
 +        break;
 +    default:
 +        av_assert0(0);
 +    }
 +
 +    switch (p->filter_type) {
 +    case biquad:
 +        break;
 +    case equalizer:
 +        p->a0 =   1 + alpha / A;
 +        p->a1 =  -2 * cos(w0);
 +        p->a2 =   1 - alpha / A;
 +        p->b0 =   1 + alpha * A;
 +        p->b1 =  -2 * cos(w0);
 +        p->b2 =   1 - alpha * A;
 +        break;
 +    case bass:
 +        p->a0 =          (A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;
 +        p->a1 =    -2 * ((A - 1) + (A + 1) * cos(w0));
 +        p->a2 =          (A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;
 +        p->b0 =     A * ((A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);
 +        p->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));
 +        p->b2 =     A * ((A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);
 +        break;
 +    case treble:
 +        p->a0 =          (A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;
 +        p->a1 =     2 * ((A - 1) - (A + 1) * cos(w0));
 +        p->a2 =          (A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;
 +        p->b0 =     A * ((A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);
 +        p->b1 =-2 * A * ((A - 1) + (A + 1) * cos(w0));
 +        p->b2 =     A * ((A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);
 +        break;
 +    case bandpass:
 +        if (p->csg) {
 +            p->a0 =  1 + alpha;
 +            p->a1 = -2 * cos(w0);
 +            p->a2 =  1 - alpha;
 +            p->b0 =  sin(w0) / 2;
 +            p->b1 =  0;
 +            p->b2 = -sin(w0) / 2;
 +        } else {
 +            p->a0 =  1 + alpha;
 +            p->a1 = -2 * cos(w0);
 +            p->a2 =  1 - alpha;
 +            p->b0 =  alpha;
 +            p->b1 =  0;
 +            p->b2 = -alpha;
 +        }
 +        break;
 +    case bandreject:
 +        p->a0 =  1 + alpha;
 +        p->a1 = -2 * cos(w0);
 +        p->a2 =  1 - alpha;
 +        p->b0 =  1;
 +        p->b1 = -2 * cos(w0);
 +        p->b2 =  1;
 +        break;
 +    case lowpass:
 +        if (p->poles == 1) {
 +            p->a0 = 1;
 +            p->a1 = -exp(-w0);
 +            p->a2 = 0;
 +            p->b0 = 1 + p->a1;
 +            p->b1 = 0;
 +            p->b2 = 0;
 +        } else {
 +            p->a0 =  1 + alpha;
 +            p->a1 = -2 * cos(w0);
 +            p->a2 =  1 - alpha;
 +            p->b0 = (1 - cos(w0)) / 2;
 +            p->b1 =  1 - cos(w0);
 +            p->b2 = (1 - cos(w0)) / 2;
 +        }
 +        break;
 +    case highpass:
 +        if (p->poles == 1) {
 +            p->a0 = 1;
 +            p->a1 = -exp(-w0);
 +            p->a2 = 0;
 +            p->b0 = (1 - p->a1) / 2;
 +            p->b1 = -p->b0;
 +            p->b2 = 0;
 +        } else {
 +            p->a0 =   1 + alpha;
 +            p->a1 =  -2 * cos(w0);
 +            p->a2 =   1 - alpha;
 +            p->b0 =  (1 + cos(w0)) / 2;
 +            p->b1 = -(1 + cos(w0));
 +            p->b2 =  (1 + cos(w0)) / 2;
 +        }
 +        break;
 +    case allpass:
 +        p->a0 =  1 + alpha;
 +        p->a1 = -2 * cos(w0);
 +        p->a2 =  1 - alpha;
 +        p->b0 =  1 - alpha;
 +        p->b1 = -2 * cos(w0);
 +        p->b2 =  1 + alpha;
 +        break;
 +    default:
 +        av_assert0(0);
 +    }
 +
 +    p->a1 /= p->a0;
 +    p->a2 /= p->a0;
 +    p->b0 /= p->a0;
 +    p->b1 /= p->a0;
 +    p->b2 /= p->a0;
 +
 +    p->cache = av_realloc_f(p->cache, sizeof(ChanCache), inlink->channels);
 +    if (!p->cache)
 +        return AVERROR(ENOMEM);
 +    memset(p->cache, 0, sizeof(ChanCache) * inlink->channels);
 +
 +    switch (inlink->format) {
 +    case AV_SAMPLE_FMT_S16P: p->filter = biquad_s16; break;
 +    case AV_SAMPLE_FMT_S32P: p->filter = biquad_s32; break;
 +    case AV_SAMPLE_FMT_FLTP: p->filter = biquad_flt; break;
 +    case AV_SAMPLE_FMT_DBLP: p->filter = biquad_dbl; break;
 +    default: av_assert0(0);
 +    }
 +
 +    return 0;
 +}
 +
-     AVFilterBufferRef *out_buf;
-     int nb_samples = buf->audio->nb_samples;
++static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
 +{
 +    BiquadsContext *p       = inlink->dst->priv;
 +    AVFilterLink *outlink   = inlink->dst->outputs[0];
-     if (buf->perms & AV_PERM_WRITE) {
++    AVFrame *out_buf;
++    int nb_samples = buf->nb_samples;
 +    int ch;
 +
-         out_buf = ff_get_audio_buffer(inlink, AV_PERM_WRITE, nb_samples);
++    if (av_frame_is_writable(buf)) {
 +        out_buf = buf;
 +    } else {
-     for (ch = 0; ch < buf->audio->channels; ch++)
++        out_buf = ff_get_audio_buffer(inlink, nb_samples);
 +        if (!out_buf)
 +            return AVERROR(ENOMEM);
 +        out_buf->pts = buf->pts;
 +    }
 +
-         avfilter_unref_buffer(buf);
++    for (ch = 0; ch < buf->channels; ch++)
 +        p->filter(buf->extended_data[ch],
 +                  out_buf->extended_data[ch], nb_samples,
 +                  &p->cache[ch].i1, &p->cache[ch].i2,
 +                  &p->cache[ch].o1, &p->cache[ch].o2,
 +                  p->b0, p->b1, p->b2, p->a1, p->a2);
 +
 +    if (buf != out_buf)
++        av_frame_free(&buf);
 +
 +    return ff_filter_frame(outlink, out_buf);
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    BiquadsContext *p = ctx->priv;
 +
 +    av_freep(&p->cache);
 +    av_opt_free(p);
 +}
 +
 +static const AVFilterPad inputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad outputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .config_props = config_output,
 +    },
 +    { NULL }
 +};
 +
 +#define OFFSET(x) offsetof(BiquadsContext, x)
 +#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
 +#define DEFINE_BIQUAD_FILTER(name_, description_)                       \
 +AVFILTER_DEFINE_CLASS(name_);                                           \
 +static av_cold int name_##_init(AVFilterContext *ctx, const char *args) \
 +{                                                                       \
 +    BiquadsContext *p = ctx->priv;                                      \
 +    p->class = &name_##_class;                                          \
 +    p->filter_type = name_;                                             \
 +    return init(ctx, args);                                             \
 +}                                                                       \
 +                                                         \
 +AVFilter avfilter_af_##name_ = {                         \
 +    .name          = #name_,                             \
 +    .description   = NULL_IF_CONFIG_SMALL(description_), \
 +    .priv_size     = sizeof(BiquadsContext),             \
 +    .init          = name_##_init,                       \
 +    .uninit        = uninit,                             \
 +    .query_formats = query_formats,                      \
 +    .inputs        = inputs,                             \
 +    .outputs       = outputs,                            \
 +    .priv_class    = &name_##_class,                     \
 +}
 +
 +#if CONFIG_EQUALIZER_FILTER
 +static const AVOption equalizer_options[] = {
 +    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
 +    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},
 +    {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},
 +    {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 +    {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");
 +#endif  /* CONFIG_EQUALIZER_FILTER */
 +#if CONFIG_BASS_FILTER
 +static const AVOption bass_options[] = {
 +    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
 +    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 +    {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 +    {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 +    {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");
 +#endif  /* CONFIG_BASS_FILTER */
 +#if CONFIG_TREBLE_FILTER
 +static const AVOption treble_options[] = {
 +    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 +    {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 +    {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 +    {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");
 +#endif  /* CONFIG_TREBLE_FILTER */
 +#if CONFIG_BANDPASS_FILTER
 +static const AVOption bandpass_options[] = {
 +    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 +    {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 +    {"csg",   "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");
 +#endif  /* CONFIG_BANDPASS_FILTER */
 +#if CONFIG_BANDREJECT_FILTER
 +static const AVOption bandreject_options[] = {
 +    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 +    {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");
 +#endif  /* CONFIG_BANDREJECT_FILTER */
 +#if CONFIG_LOWPASS_FILTER
 +static const AVOption lowpass_options[] = {
 +    {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
 +    {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 +    {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 +    {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 +    {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");
 +#endif  /* CONFIG_LOWPASS_FILTER */
 +#if CONFIG_HIGHPASS_FILTER
 +static const AVOption highpass_options[] = {
 +    {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 +    {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 +    {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 +    {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");
 +#endif  /* CONFIG_HIGHPASS_FILTER */
 +#if CONFIG_ALLPASS_FILTER
 +static const AVOption allpass_options[] = {
 +    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 +    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HZ}, HZ, SLOPE, FLAGS, "width_type"},
 +    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
 +    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 +    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 +    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 +    {"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
 +    {"w",     "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");
 +#endif  /* CONFIG_ALLPASS_FILTER */
 +#if CONFIG_BIQUAD_FILTER
 +static const AVOption biquad_options[] = {
 +    {"a0", NULL, OFFSET(a0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},
 +    {"a1", NULL, OFFSET(a1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},
 +    {"a2", NULL, OFFSET(a2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},
 +    {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},
 +    {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},
 +    {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MAX, INT16_MAX, FLAGS},
 +    {NULL},
 +};
 +
 +DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");
 +#endif  /* CONFIG_BIQUAD_FILTER */
Simple merge
Simple merge
index a169d2a,0000000..b1d3d6f
mode 100644,000000..100644
--- /dev/null
@@@ -1,170 -1,0 +1,169 @@@
- static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)
 +/*
 + * Copyright (c) 2011 Mina Nagy Zaki
 + * Copyright (c) 2000 Edward Beingessner And Sundry Contributors.
 + * This source code is freely redistributable and may be used for any purpose.
 + * This copyright notice must be maintained.  Edward Beingessner And Sundry
 + * Contributors are not responsible for the consequences of using this
 + * software.
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * Stereo Widening Effect. Adds audio cues to move stereo image in
 + * front of the listener. Adapted from the libsox earwax effect.
 + */
 +
 +#include "libavutil/channel_layout.h"
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "formats.h"
 +
 +#define NUMTAPS 64
 +
 +static const int8_t filt[NUMTAPS] = {
 +/* 30°  330° */
 +    4,   -6,     /* 32 tap stereo FIR filter. */
 +    4,  -11,     /* One side filters as if the */
 +   -1,   -5,     /* signal was from 30 degrees */
 +    3,    3,     /* from the ear, the other as */
 +   -2,    5,     /* if 330 degrees. */
 +   -5,    0,
 +    9,    1,
 +    6,    3,     /*                         Input                         */
 +   -4,   -1,     /*                   Left         Right                  */
 +   -5,   -3,     /*                __________   __________                */
 +   -2,   -5,     /*               |          | |          |               */
 +   -7,    1,     /*           .---|  Hh,0(f) | |  Hh,0(f) |---.           */
 +    6,   -7,     /*          /    |__________| |__________|    \          */
 +   30,  -29,     /*         /                \ /                \         */
 +   12,   -3,     /*        /                  X                  \        */
 +  -11,    4,     /*       /                  / \                  \       */
 +   -3,    7,     /*  ____V_____   __________V   V__________   _____V____  */
 +  -20,   23,     /* |          | |          |   |          | |          | */
 +    2,    0,     /* | Hh,30(f) | | Hh,330(f)|   | Hh,330(f)| | Hh,30(f) | */
 +    1,   -6,     /* |__________| |__________|   |__________| |__________| */
 +  -14,   -5,     /*      \     ___      /           \      ___     /      */
 +   15,  -18,     /*       \   /   \    /    _____    \    /   \   /       */
 +    6,    7,     /*        `->| + |<--'    /     \    `-->| + |<-'        */
 +   15,  -10,     /*           \___/      _/       \_      \___/           */
 +  -14,   22,     /*               \     / \       / \     /               */
 +   -7,   -2,     /*                `--->| |       | |<---'                */
 +   -4,    9,     /*                     \_/       \_/                     */
 +    6,  -12,     /*                                                       */
 +    6,   -6,     /*                       Headphones                      */
 +    0,  -11,
 +    0,   -5,
 +    4,    0};
 +
 +typedef struct {
 +    int16_t taps[NUMTAPS * 2];
 +} EarwaxContext;
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    static const int sample_rates[] = { 44100, -1 };
 +
 +    AVFilterFormats *formats = NULL;
 +    AVFilterChannelLayouts *layout = NULL;
 +
 +    ff_add_format(&formats, AV_SAMPLE_FMT_S16);
 +    ff_set_common_formats(ctx, formats);
 +    ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
 +    ff_set_common_channel_layouts(ctx, layout);
 +    ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates));
 +
 +    return 0;
 +}
 +
 +//FIXME: replace with DSPContext.scalarproduct_int16
 +static inline int16_t *scalarproduct(const int16_t *in, const int16_t *endin, int16_t *out)
 +{
 +    int32_t sample;
 +    int16_t j;
 +
 +    while (in < endin) {
 +        sample = 32;
 +        for (j = 0; j < NUMTAPS; j++)
 +            sample += in[j] * filt[j];
 +        *out = sample >> 6;
 +        out++;
 +        in++;
 +    }
 +
 +    return out;
 +}
 +
-     AVFilterBufferRef *outsamples =
-         ff_get_audio_buffer(inlink, AV_PERM_WRITE,
-                                   insamples->audio->nb_samples);
++static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 +{
 +    AVFilterLink *outlink = inlink->dst->outputs[0];
 +    int16_t *taps, *endin, *in, *out;
-     if (!outsamples)
++    AVFrame *outsamples = ff_get_audio_buffer(inlink, insamples->nb_samples);
 +    int ret;
 +
-     avfilter_copy_buffer_ref_props(outsamples, insamples);
++    if (!outsamples) {
++        av_frame_free(&insamples);
 +        return AVERROR(ENOMEM);
-     endin = in + insamples->audio->nb_samples * 2 - NUMTAPS;
++    }
++    av_frame_copy_props(outsamples, insamples);
 +
 +    taps  = ((EarwaxContext *)inlink->dst->priv)->taps;
 +    out   = (int16_t *)outsamples->data[0];
 +    in    = (int16_t *)insamples ->data[0];
 +
 +    // copy part of new input and process with saved input
 +    memcpy(taps+NUMTAPS, in, NUMTAPS * sizeof(*taps));
 +    out   = scalarproduct(taps, taps + NUMTAPS, out);
 +
 +    // process current input
-     avfilter_unref_buffer(insamples);
++    endin = in + insamples->nb_samples * 2 - NUMTAPS;
 +    scalarproduct(in, endin, out);
 +
 +    // save part of input for next round
 +    memcpy(taps, endin, NUMTAPS * sizeof(*taps));
 +
 +    ret = ff_filter_frame(outlink, outsamples);
-         .min_perms    = AV_PERM_READ,
++    av_frame_free(&insamples);
 +    return ret;
 +}
 +
 +static const AVFilterPad earwax_inputs[] = {
 +    {
 +        .name         = "default",
 +        .type         = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame = filter_frame,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad earwax_outputs[] = {
 +    {
 +        .name = "default",
 +        .type = AVMEDIA_TYPE_AUDIO,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_earwax = {
 +    .name           = "earwax",
 +    .description    = NULL_IF_CONFIG_SMALL("Widen the stereo image."),
 +    .query_formats  = query_formats,
 +    .priv_size      = sizeof(EarwaxContext),
 +    .inputs         = earwax_inputs,
 +    .outputs        = earwax_outputs,
 +};