Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 25 Jan 2013 14:04:41 +0000 (15:04 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 25 Jan 2013 14:04:41 +0000 (15:04 +0100)
* qatar/master:
  avfilter: allow setpts filter to use wallclock time for calculations

Conflicts:
doc/filters.texi

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

@@@ -5259,497 -1795,485 +5259,510 @@@ Select frames with a minimum distance o
  select='isnan(prev_selected_t)+gte(t-prev_selected_t\,10)'
  @end example
  
 -@anchor{setdar}
 -@section setdar
 -
 -Set 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:
 -@math{DAR = HORIZONTAL_RESOLUTION / VERTICAL_RESOLUTION * SAR}
 -
 -Keep in mind that this 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 filter accepts a parameter string which represents the wanted
 -display aspect ratio.
 -The parameter can be a floating point number string, or an expression
 -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:1".
 -
 -For example to change the display aspect ratio to 16:9, specify:
 +@item
 +Use aselect to select only audio frames with samples number > 100:
  @example
 -setdar=16:9
 -# the above is equivalent to
 -setdar=1.77777
 +aselect='gt(samples_n\,100)'
  @end example
  
 -See also the @ref{setsar} filter documentation.
 -
 -@section setpts
 +@item
 +Create a mosaic of the first scenes:
 +@example
 +ffmpeg -i video.avi -vf select='gt(scene\,0.4)',scale=160:120,tile -frames:v 1 preview.png
 +@end example
  
 -Change the PTS (presentation timestamp) of the input video frames.
 +Comparing @var{scene} against a value between 0.3 and 0.5 is generally a sane
 +choice.
 +@end itemize
  
 -Accept in input an expression evaluated through the eval API, which
 -can contain the following constants:
 +@section asendcmd, sendcmd
  
 -@table @option
 -@item PTS
 -the presentation timestamp in input
 +Send commands to filters in the filtergraph.
  
 -@item PI
 -Greek PI
 +These filters read commands to be sent to other filters in the
 +filtergraph.
  
 -@item PHI
 -golden ratio
 +@code{asendcmd} must be inserted between two audio filters,
 +@code{sendcmd} must be inserted between two video filters, but apart
 +from that they act the same way.
  
 -@item E
 -Euler number
 +The specification of commands can be provided in the filter arguments
 +with the @var{commands} option, or in a file specified by the
 +@var{filename} option.
  
 -@item N
 -the count of the input frame, starting from 0.
 +These filters accept the following options:
 +@table @option
 +@item commands, c
 +Set the commands to be read and sent to the other filters.
 +@item filename, f
 +Set the filename of the commands to be read and sent to the other
 +filters.
 +@end table
  
 -@item STARTPTS
 -the PTS of the first video frame
 +@subsection Commands syntax
  
 -@item INTERLACED
 -tell if the current frame is interlaced
 +A commands description consists of a sequence of interval
 +specifications, comprising a list of commands to be executed when a
 +particular event related to that interval occurs. The occurring event
 +is typically the current frame time entering or leaving a given time
 +interval.
  
 -@item POS
 -original position in the file of the frame, or undefined if undefined
 -for the current frame
 +An interval is specified by the following syntax:
 +@example
 +@var{START}[-@var{END}] @var{COMMANDS};
 +@end example
  
 -@item PREV_INPTS
 -previous input PTS
 +The time interval is specified by the @var{START} and @var{END} times.
 +@var{END} is optional and defaults to the maximum time.
  
 -@item PREV_OUTPTS
 -previous output PTS
 +The current frame time is considered within the specified interval if
 +it is included in the interval [@var{START}, @var{END}), that is when
 +the time is greater or equal to @var{START} and is lesser than
 +@var{END}.
  
 -@item RTCTIME
 -wallclock (RTC) time in microseconds
 +@var{COMMANDS} consists of a sequence of one or more command
 +specifications, separated by ",", relating to that interval.  The
 +syntax of a command specification is given by:
 +@example
 +[@var{FLAGS}] @var{TARGET} @var{COMMAND} @var{ARG}
 +@end example
  
 -@item RTCSTART
 -wallclock (RTC) time at the start of the movie in microseconds
 +@var{FLAGS} is optional and specifies the type of events relating to
 +the time interval which enable sending the specified command, and must
 +be a non-null sequence of identifier flags separated by "+" or "|" and
 +enclosed between "[" and "]".
  
 +The following flags are recognized:
 +@table @option
 +@item enter
 +The command is sent when the current frame timestamp enters the
 +specified interval. In other words, the command is sent when the
 +previous frame timestamp was not in the given interval, and the
 +current is.
 +
 +@item leave
 +The command is sent when the current frame timestamp leaves the
 +specified interval. In other words, the command is sent when the
 +previous frame timestamp was in the given interval, and the
 +current is not.
  @end table
  
 -Some examples follow:
 -
 -@example
 -# start counting PTS from zero
 -setpts=PTS-STARTPTS
 +If @var{FLAGS} is not specified, a default value of @code{[enter]} is
 +assumed.
  
 -# fast motion
 -setpts=0.5*PTS
 +@var{TARGET} specifies the target of the command, usually the name of
 +the filter class or a specific filter instance name.
  
 -# slow motion
 -setpts=2.0*PTS
 +@var{COMMAND} specifies the name of the command for the target filter.
  
 -# fixed rate 25 fps
 -setpts=N/(25*TB)
 +@var{ARG} is optional and specifies the optional list of argument for
 +the given @var{COMMAND}.
  
 -# fixed rate 25 fps with some jitter
 -setpts='1/(25*TB) * (N + 0.05 * sin(N*2*PI/25))'
 +Between one interval specification and another, whitespaces, or
 +sequences of characters starting with @code{#} until the end of line,
 +are ignored and can be used to annotate comments.
  
 -# generate timestamps from a "live source" and rebase onto the current timebase
 -setpts='(RTCTIME - RTCSTART) / (TB * 1000000)"
 +A simplified BNF description of the commands specification syntax
 +follows:
 +@example
 +@var{COMMAND_FLAG}  ::= "enter" | "leave"
 +@var{COMMAND_FLAGS} ::= @var{COMMAND_FLAG} [(+|"|")@var{COMMAND_FLAG}]
 +@var{COMMAND}       ::= ["[" @var{COMMAND_FLAGS} "]"] @var{TARGET} @var{COMMAND} [@var{ARG}]
 +@var{COMMANDS}      ::= @var{COMMAND} [,@var{COMMANDS}]
 +@var{INTERVAL}      ::= @var{START}[-@var{END}] @var{COMMANDS}
 +@var{INTERVALS}     ::= @var{INTERVAL}[;@var{INTERVALS}]
  @end example
  
 -@anchor{setsar}
 -@section setsar
 -
 -Set 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 following
 -equation:
 -@math{DAR = HORIZONTAL_RESOLUTION / VERTICAL_RESOLUTION * SAR}
 -
 -Keep in mind that the sample aspect ratio set by this filter may be
 -changed by later filters in the filterchain, e.g. if another "setsar"
 -or a "setdar" filter is applied.
 -
 -The filter accepts a parameter string which represents the wanted
 -sample aspect ratio.
 -The parameter can be a floating point number string, or an expression
 -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:1".
 +@subsection Examples
  
 -For example to change the sample aspect ratio to 10:11, specify:
 +@itemize
 +@item
 +Specify audio tempo change at second 4:
  @example
 -setsar=10:11
 +asendcmd=c='4.0 atempo tempo 1.5',atempo
  @end example
  
 -@section settb
 -
 -Set the timebase to use for the output frames timestamps.
 -It is mainly useful for testing timebase configuration.
 +@item
 +Specify a list of drawtext and hue commands in a file.
 +@example
 +# show text in the interval 5-10
 +5.0-10.0 [enter] drawtext reinit 'fontfile=FreeSerif.ttf:text=hello world',
 +         [leave] drawtext reinit 'fontfile=FreeSerif.ttf:text=';
 +
 +# desaturate the image in the interval 15-20
 +15.0-20.0 [enter] hue reinit s=0,
 +          [enter] drawtext reinit 'fontfile=FreeSerif.ttf:text=nocolor',
 +          [leave] hue reinit s=1,
 +          [leave] drawtext reinit 'fontfile=FreeSerif.ttf:text=color';
 +
 +# apply an exponential saturation fade-out effect, starting from time 25
 +25 [enter] hue s=exp(t-25)
 +@end example
  
 -It accepts in input an arithmetic expression representing a rational.
 -The expression can contain the constants "PI", "E", "PHI", "AVTB" (the
 -default timebase), and "intb" (the input timebase).
 +A filtergraph allowing to read and process the above command list
 +stored in a file @file{test.cmd}, can be specified with:
 +@example
 +sendcmd=f=test.cmd,drawtext=fontfile=FreeSerif.ttf:text='',hue
 +@end example
 +@end itemize
  
 -The default value for the input is "intb".
 +@anchor{setpts}
 +@section asetpts, setpts
  
 -Follow some examples.
 +Change the PTS (presentation timestamp) of the input frames.
  
 -@example
 -# set the timebase to 1/25
 -settb=1/25
 +@code{asetpts} works on audio frames, @code{setpts} on video frames.
  
 -# set the timebase to 1/10
 -settb=0.1
 +Accept in input an expression evaluated through the eval API, which
 +can contain the following constants:
  
 -#set the timebase to 1001/1000
 -settb=1+0.001
 +@table @option
 +@item FRAME_RATE
 +frame rate, only defined for constant frame-rate video
  
 -#set the timebase to 2*intb
 -settb=2*intb
 +@item PTS
 +the presentation timestamp in input
  
 -#set the default timebase value
 -settb=AVTB
 -@end example
 +@item N
 +the count of the input frame, starting from 0.
  
 -@section showinfo
 +@item NB_CONSUMED_SAMPLES
 +the number of consumed samples, not including the current frame (only
 +audio)
  
 -Show a line containing various information for each input video frame.
 -The input video is not modified.
 +@item NB_SAMPLES
 +the number of samples in the current frame (only audio)
  
 -The shown line contains a sequence of key/value pairs of the form
 -@var{key}:@var{value}.
 +@item SAMPLE_RATE
 +audio sample rate
  
 -A description of each shown parameter follows:
 +@item STARTPTS
 +the PTS of the first frame
  
 -@table @option
 -@item n
 -sequential number of the input frame, starting from 0
 +@item STARTT
 +the time in seconds of the first frame
  
 -@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 INTERLACED
 +tell if the current frame is interlaced
  
 -@item pts_time
 -Presentation TimeStamp of the input frame, expressed as a number of
 -seconds
 +@item T
 +the time in seconds of the current frame
  
 -@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 TB
 +the time base
  
 -@item fmt
 -pixel format name
 +@item POS
 +original position in the file of the frame, or undefined if undefined
 +for the current frame
  
 -@item sar
 -sample aspect ratio of the input frame, expressed in the form
 -@var{num}/@var{den}
 +@item PREV_INPTS
 +previous input PTS
  
 -@item s
 -size of the input frame, expressed in the form
 -@var{width}x@var{height}
 +@item PREV_INT
 +previous input time in seconds
  
 -@item i
 -interlaced mode ("P" for "progressive", "T" for top field first, "B"
 -for bottom field first)
 +@item PREV_OUTPTS
 +previous output PTS
  
 -@item iskey
 -1 if the frame is a key frame, 0 otherwise
 +@item PREV_OUTT
 +previous output time in seconds
 -@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}.
++@item RTCTIME
++wallclock (RTC) time in microseconds
 -@item checksum
 -Adler-32 checksum of all the planes of the input frame
++@item RTCSTART
++wallclock (RTC) time at the start of the movie in microseconds
 -@item plane_checksum
 -Adler-32 checksum of each plane of the input frame, expressed in the form
 -"[@var{c0} @var{c1} @var{c2} @var{c3}]"
  @end table
  
 -@section split
 -
 -Split input video into several identical outputs.
 -
 -The filter accepts a single parameter which specifies the number of outputs. If
 -unspecified, it defaults to 2.
 +@subsection Examples
  
 -For example
 +@itemize
 +@item
 +Start counting PTS from zero
  @example
 -avconv -i INPUT -filter_complex split=5 OUTPUT
 +setpts=PTS-STARTPTS
  @end example
 -will create 5 copies of the input video.
 -
 -@section transpose
  
 -Transpose rows with columns in the input video and optionally flip it.
 -
 -It accepts a parameter representing an integer, which can assume the
 -values:
 -
 -@table @samp
 -@item 0
 -Rotate by 90 degrees counterclockwise and vertically flip (default), that is:
 +@item
 +Apply fast motion effect:
  @example
 -L.R     L.l
 -. . ->  . .
 -l.r     R.r
 +setpts=0.5*PTS
  @end example
  
 -@item 1
 -Rotate by 90 degrees clockwise, that is:
 +@item
 +Apply slow motion effect:
  @example
 -L.R     l.L
 -. . ->  . .
 -l.r     r.R
 +setpts=2.0*PTS
  @end example
  
 -@item 2
 -Rotate by 90 degrees counterclockwise, that is:
 +@item
 +Set fixed rate of 25 frames per second:
  @example
 -L.R     R.r
 -. . ->  . .
 -l.r     L.l
 +setpts=N/(25*TB)
  @end example
  
 -@item 3
 -Rotate by 90 degrees clockwise and vertically flip, that is:
 +@item
 +Set fixed rate 25 fps with some jitter:
  @example
 -L.R     r.R
 -. . ->  . .
 -l.r     l.L
 +setpts='1/(25*TB) * (N + 0.05 * sin(N*2*PI/25))'
  @end example
 -@end table
 -
 -@section unsharp
 -
 -Sharpen or blur the input video.
 -
 -It accepts the following parameters:
 -@var{luma_msize_x}:@var{luma_msize_y}:@var{luma_amount}:@var{chroma_msize_x}:@var{chroma_msize_y}:@var{chroma_amount}
 -
 -Negative values for the amount will blur the input video, while positive
 -values will sharpen. All parameters are optional and default to the
 -equivalent of the string '5:5:1.0:5:5:0.0'.
 -
 -@table @option
 -
 -@item luma_msize_x
 -Set the luma matrix horizontal size. It can be an integer between 3
 -and 13, default value is 5.
  
 -@item luma_msize_y
 -Set the luma matrix vertical size. It can be an integer between 3
 -and 13, default value is 5.
 +@item
 +Apply an offset of 10 seconds to the input PTS:
 +@example
 +setpts=PTS+10/TB
 +@end example
 -@item luma_amount
 -Set the luma effect strength. It can be a float number between -2.0
 -and 5.0, default value is 1.0.
++@item
++generate timestamps from a "live source" and rebase onto the current timebase
++@example
++setpts='(RTCTIME - RTCSTART) / (TB * 1000000)'
++@end example
 +@end itemize
  
 -@item chroma_msize_x
 -Set the chroma matrix horizontal size. It can be an integer between 3
 -and 13, default value is 5.
 +@section ebur128
  
 -@item chroma_msize_y
 -Set the chroma matrix vertical size. It can be an integer between 3
 -and 13, default value is 5.
 +EBU R128 scanner filter. This filter takes an audio stream as input and outputs
 +it unchanged. By default, it logs a message at a frequency of 10Hz with the
 +Momentary loudness (identified by @code{M}), Short-term loudness (@code{S}),
 +Integrated loudness (@code{I}) and Loudness Range (@code{LRA}).
  
 -@item luma_amount
 -Set the chroma effect strength. It can be a float number between -2.0
 -and 5.0, default value is 0.0.
 +The filter also has a video output (see the @var{video} option) with a real
 +time graph to observe the loudness evolution. The graphic contains the logged
 +message mentioned above, so it is not printed anymore when this option is set,
 +unless the verbose logging is set. The main graphing area contains the
 +short-term loudness (3 seconds of analysis), and the gauge on the right is for
 +the momentary loudness (400 milliseconds).
  
 -@end table
 +More information about the Loudness Recommendation EBU R128 on
 +@url{http://tech.ebu.ch/loudness}.
  
 -@example
 -# Strong luma sharpen effect parameters
 -unsharp=7:7:2.5
 +The filter accepts the following named parameters:
  
 -# Strong blur of both luma and chroma parameters
 -unsharp=7:7:-2:7:7:-2
 +@table @option
  
 -# Use the default values with @command{avconv}
 -./avconv -i in.avi -vf "unsharp" out.mp4
 -@end example
 +@item video
 +Activate the video output. The audio stream is passed unchanged whether this
 +option is set or no. The video stream will be the first output stream if
 +activated. Default is @code{0}.
  
 -@section vflip
 +@item size
 +Set the video size. This option is for video only. Default and minimum
 +resolution is @code{640x480}.
  
 -Flip the input video vertically.
 +@item meter
 +Set the EBU scale meter. Default is @code{9}. Common values are @code{9} and
 +@code{18}, respectively for EBU scale meter +9 and EBU scale meter +18. Any
 +other integer value between this range is allowed.
  
 +@end table
 +
 +Example of real-time graph using @command{ffplay}, with a EBU scale meter +18:
  @example
 -./avconv -i in.avi -vf "vflip" out.avi
 +ffplay -f lavfi -i "amovie=input.mp3,ebur128=video=1:meter=18 [out0][out1]"
  @end example
  
 -@section yadif
 +Run an analysis with @command{ffmpeg}:
 +@example
 +ffmpeg -nostats -i input.mp3 -filter_complex ebur128 -f null -
 +@end example
  
 -Deinterlace the input video ("yadif" means "yet another deinterlacing
 -filter").
 +@section settb, asettb
  
 -It accepts the optional parameters: @var{mode}:@var{parity}:@var{auto}.
 +Set the timebase to use for the output frames timestamps.
 +It is mainly useful for testing timebase configuration.
  
 -@var{mode} specifies the interlacing mode to adopt, accepts one of the
 -following values:
 +It accepts in input an arithmetic expression representing a rational.
 +The expression can contain the constants "AVTB" (the
 +default timebase), "intb" (the input timebase) and "sr" (the sample rate,
 +audio only).
  
 -@table @option
 -@item 0
 -output 1 frame for each frame
 -@item 1
 -output 1 frame for each field
 -@item 2
 -like 0 but skips spatial interlacing check
 -@item 3
 -like 1 but skips spatial interlacing check
 -@end table
 +The default value for the input is "intb".
  
 -Default value is 0.
 +@subsection Examples
  
 -@var{parity} specifies the picture field parity assumed for the input
 -interlaced video, accepts one of the following values:
 +@itemize
 +@item
 +Set the timebase to 1/25:
 +@example
 +settb=1/25
 +@end example
  
 -@table @option
 -@item 0
 -assume top field first
 -@item 1
 -assume bottom field first
 -@item -1
 -enable automatic detection
 -@end table
 +@item
 +Set the timebase to 1/10:
 +@example
 +settb=0.1
 +@end example
  
 -Default value is -1.
 -If interlacing is unknown or decoder does not export this information,
 -top field first will be assumed.
 +@item
 +Set the timebase to 1001/1000:
 +@example
 +settb=1+0.001
 +@end example
  
 -@var{auto} specifies if deinterlacer should trust the interlaced flag
 -and only deinterlace frames marked as interlaced
 +@item
 +Set the timebase to 2*intb:
 +@example
 +settb=2*intb
 +@end example
  
 -@table @option
 -@item 0
 -deinterlace all frames
 -@item 1
 -only deinterlace frames marked as interlaced
 -@end table
 +@item
 +Set the default timebase value:
 +@example
 +settb=AVTB
 +@end example
 +@end itemize
  
 -Default value is 0.
 +@section concat
  
 -@c man end VIDEO FILTERS
 +Concatenate audio and video streams, joining them together one after the
 +other.
  
 -@chapter Video Sources
 -@c man begin VIDEO SOURCES
 +The filter works on segments of synchronized video and audio streams. All
 +segments must have the same number of streams of each type, and that will
 +also be the number of streams at output.
  
 -Below is a description of the currently available video sources.
 +The filter accepts the following named parameters:
 +@table @option
  
 -@section buffer
 +@item n
 +Set the number of segments. Default is 2.
  
 -Buffer video frames, and make them available to the filter chain.
 +@item v
 +Set the number of output video streams, that is also the number of video
 +streams in each segment. Default is 1.
  
 -This source is mainly intended for a programmatic use, in particular
 -through the interface defined in @file{libavfilter/vsrc_buffer.h}.
 +@item a
 +Set the number of output audio streams, that is also the number of video
 +streams in each segment. Default is 0.
  
 -It accepts the following parameters:
 -@var{width}:@var{height}:@var{pix_fmt_string}:@var{timebase_num}:@var{timebase_den}:@var{sample_aspect_ratio_num}:@var{sample_aspect_ratio.den}
 +@item unsafe
 +Activate unsafe mode: do not fail if segments have a different format.
  
 -All the parameters need to be explicitly defined.
 +@end table
  
 -Follows the list of the accepted parameters.
 +The filter has @var{v}+@var{a} outputs: first @var{v} video outputs, then
 +@var{a} audio outputs.
  
 -@table @option
 +There are @var{n}×(@var{v}+@var{a}) inputs: first the inputs for the first
 +segment, in the same order as the outputs, then the inputs for the second
 +segment, etc.
  
 -@item width, height
 -Specify the width and height of the buffered video frames.
 +Related streams do not always have exactly the same duration, for various
 +reasons including codec frame size or sloppy authoring. For that reason,
 +related synchronized streams (e.g. a video and its audio track) should be
 +concatenated at once. The concat filter will use the duration of the longest
 +stream in each segment (except the last one), and if necessary pad shorter
 +audio streams with silence.
  
 -@item pix_fmt_string
 -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.
 +For this filter to work correctly, all segments must start at timestamp 0.
  
 -@item timebase_num, timebase_den
 -Specify numerator and denomitor of the timebase assumed by the
 -timestamps of the buffered frames.
 +All corresponding streams must have the same parameters in all segments; the
 +filtering system will automatically select a common pixel format for video
 +streams, and a common sample format, sample rate and channel layout for
 +audio streams, but other settings, such as resolution, must be converted
 +explicitly by the user.
  
 -@item sample_aspect_ratio.num, sample_aspect_ratio.den
 -Specify numerator and denominator of the sample aspect ratio assumed
 -by the video frames.
 -@end table
 +Different frame rates are acceptable but will result in variable frame rate
 +at output; be sure to configure the output file to handle it.
  
 -For example:
 +Examples:
 +@itemize
 +@item
 +Concatenate an opening, an episode and an ending, all in bilingual version
 +(video in stream 0, audio in streams 1 and 2):
  @example
 -buffer=320:240:yuv410p:1:24:1:1
 +ffmpeg -i opening.mkv -i episode.mkv -i ending.mkv -filter_complex \
 +  '[0:0] [0:1] [0:2] [1:0] [1:1] [1:2] [2:0] [2:1] [2:2]
 +   concat=n=3:v=1:a=2 [v] [a1] [a2]' \
 +  -map '[v]' -map '[a1]' -map '[a2]' output.mkv
  @end example
  
 -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:
 +@item
 +Concatenate two parts, handling audio and video separately, using the
 +(a)movie sources, and adjusting the resolution:
  @example
 -buffer=320:240:6:1:24
 +movie=part1.mp4, scale=512:288 [v1] ; amovie=part1.mp4 [a1] ;
 +movie=part2.mp4, scale=512:288 [v2] ; amovie=part2.mp4 [a2] ;
 +[v1] [v2] concat [outv] ; [a1] [a2] concat=v=0:a=1 [outa]
  @end example
 +Note that a desync will happen at the stitch if the audio and video streams
 +do not have exactly the same duration in the first file.
  
 -@section color
 -
 -Provide an uniformly colored input.
 +@end itemize
  
 -It accepts the following parameters:
 -@var{color}:@var{frame_size}:@var{frame_rate}
 +@section showspectrum
  
 -Follows the description of the accepted parameters.
 +Convert input audio to a video output, representing the audio frequency
 +spectrum.
  
 +The filter accepts the following named parameters:
  @table @option
 +@item size, s
 +Specify the video size for the output. Default value is @code{640x480}.
 +@item slide
 +Specify if the spectrum should slide along the window. Default value is
 +@code{0}.
 +@end table
  
 -@item color
 -Specify the color of the 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".
 +The usage is very similar to the showwaves filter; see the examples in that
 +section.
  
 -@item frame_size
 -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".
 +@section showwaves
  
 -@item frame_rate
 -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".
 +Convert input audio to a video output, representing the samples waves.
 +
 +The filter accepts the following named parameters:
 +@table @option
 +
 +@item n
 +Set the number of samples which are printed on the same column. A
 +larger value will decrease the frame rate. Must be a positive
 +integer. This option can be set only if the value for @var{rate}
 +is not explicitly specified.
  
 +@item rate, r
 +Set the (approximate) output frame rate. This is done by setting the
 +option @var{n}. Default value is "25".
 +
 +@item size, s
 +Specify the video size for the output. Default value is "600x240".
  @end table
  
 -For example 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, which will be overlayed over the source connected
 -to the pad with identifier "in".
 +Some examples follow.
 +@itemize
 +@item
 +Output the input file audio and the corresponding video representation
 +at the same time:
 +@example
 +amovie=a.mp3,asplit[out0],showwaves[out1]
 +@end example
  
 +@item
 +Create a synthetic signal and show it with showwaves, forcing a
 +framerate of 30 frames per second:
  @example
 -"color=red@@0.2:qcif:10 [color]; [in][color] overlay [out]"
 +aevalsrc=sin(1*2*PI*t)*sin(880*2*PI*t):cos(2*PI*200*t),asplit[out0],showwaves=r=30[out1]
  @end example
 +@end itemize
  
 -@section movie
 +@c man end MULTIMEDIA FILTERS
  
 -Read a video stream from a movie container.
 +@chapter Multimedia Sources
 +@c man begin MULTIMEDIA SOURCES
  
 -Note that this source is a hack that bypasses the standard input path. It can be
 -useful in applications that do not support arbitrary filter graphs, but its use
 -is discouraged in those that do. Specifically in @command{avconv} this filter
 -should never be used, the @option{-filter_complex} option fully replaces it.
 +Below is a description of the currently available multimedia sources.
 +
 +@section amovie
 +
 +This is the same as @ref{movie} source, except it selects an audio
 +stream by default.
 +
 +@anchor{movie}
 +@section movie
 +
 +Read audio and/or video stream(s) from a movie container.
  
  It accepts the syntax: @var{movie_name}[:@var{options}] where
  @var{movie_name} is the name of the resource to read (not necessarily
index db1d91c,0000000..1c2edb8
mode 100644,000000..100644
--- /dev/null
@@@ -1,262 -1,0 +1,269 @@@
 +/*
 + * Copyright (c) 2010 Stefano Sabatini
 + * Copyright (c) 2008 Victor Paesa
 + *
 + * 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
 + * video presentation timestamp (PTS) modification filter
 + */
 +
 +#include "libavutil/eval.h"
 +#include "libavutil/internal.h"
 +#include "libavutil/mathematics.h"
++#include "libavutil/time.h"
 +#include "avfilter.h"
 +#include "internal.h"
 +#include "audio.h"
 +#include "video.h"
 +
 +static const char *const var_names[] = {
 +    "FRAME_RATE",  ///< defined only for constant frame-rate video
 +    "INTERLACED",  ///< tell if the current frame is interlaced
 +    "N",           ///< frame number (starting at zero)
 +    "NB_CONSUMED_SAMPLES", ///< number of samples consumed by the filter (only audio)
 +    "NB_SAMPLES",  ///< number of samples in the current frame (only audio)
 +    "POS",         ///< original position in the file of the frame
 +    "PREV_INPTS",  ///< previous  input PTS
 +    "PREV_INT",    ///< previous  input time in seconds
 +    "PREV_OUTPTS", ///< previous output PTS
 +    "PREV_OUTT",   ///< previous output time in seconds
 +    "PTS",         ///< original pts in the file of the frame
 +    "SAMPLE_RATE", ///< sample rate (only audio)
 +    "STARTPTS",    ///< PTS at start of movie
 +    "STARTT",      ///< time at start of movie
 +    "T",           ///< original time in the file of the frame
 +    "TB",          ///< timebase
++    "RTCTIME",     ///< wallclock (RTC) time in micro seconds
++    "RTCSTART",    ///< wallclock (RTC) time at the start of the movie in micro seconds
 +    NULL
 +};
 +
 +enum var_name {
 +    VAR_FRAME_RATE,
 +    VAR_INTERLACED,
 +    VAR_N,
 +    VAR_NB_CONSUMED_SAMPLES,
 +    VAR_NB_SAMPLES,
 +    VAR_POS,
 +    VAR_PREV_INPTS,
 +    VAR_PREV_INT,
 +    VAR_PREV_OUTPTS,
 +    VAR_PREV_OUTT,
 +    VAR_PTS,
 +    VAR_SAMPLE_RATE,
 +    VAR_STARTPTS,
 +    VAR_STARTT,
 +    VAR_T,
 +    VAR_TB,
++    VAR_RTCTIME,
++    VAR_RTCSTART,
 +    VAR_VARS_NB
 +};
 +
 +typedef struct {
 +    AVExpr *expr;
 +    double var_values[VAR_VARS_NB];
 +    enum AVMediaType type;
 +} SetPTSContext;
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    SetPTSContext *setpts = ctx->priv;
 +    int ret;
 +
 +    if ((ret = av_expr_parse(&setpts->expr, args ? args : "PTS",
 +                             var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n", args);
 +        return ret;
 +    }
 +
 +    setpts->var_values[VAR_N          ] = 0.0;
 +    setpts->var_values[VAR_PREV_INPTS ] = setpts->var_values[VAR_PREV_INT ] = NAN;
 +    setpts->var_values[VAR_PREV_OUTPTS] = setpts->var_values[VAR_PREV_OUTT] = NAN;
 +    setpts->var_values[VAR_STARTPTS   ] = setpts->var_values[VAR_STARTT   ] = NAN;
 +    return 0;
 +}
 +
 +static int config_input(AVFilterLink *inlink)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    SetPTSContext *setpts = ctx->priv;
 +
 +    setpts->type = inlink->type;
 +    setpts->var_values[VAR_TB] = av_q2d(inlink->time_base);
++    setpts->var_values[VAR_RTCSTART] = av_gettime();
 +
 +    setpts->var_values[VAR_SAMPLE_RATE] =
 +        setpts->type == AVMEDIA_TYPE_AUDIO ? inlink->sample_rate : NAN;
 +
 +    setpts->var_values[VAR_FRAME_RATE] = inlink->frame_rate.num && inlink->frame_rate.den ?
 +        av_q2d(inlink->frame_rate) : NAN;
 +
 +    av_log(inlink->src, AV_LOG_VERBOSE, "TB:%f FRAME_RATE:%f SAMPLE_RATE:%f\n",
 +           setpts->var_values[VAR_TB],
 +           setpts->var_values[VAR_FRAME_RATE],
 +           setpts->var_values[VAR_SAMPLE_RATE]);
 +    return 0;
 +}
 +
 +#define D2TS(d)  (isnan(d) ? AV_NOPTS_VALUE : (int64_t)(d))
 +#define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts))
 +#define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts)*av_q2d(tb))
 +
 +#define BUF_SIZE 64
 +
 +static inline char *double2int64str(char *buf, double v)
 +{
 +    if (isnan(v)) snprintf(buf, BUF_SIZE, "nan");
 +    else          snprintf(buf, BUF_SIZE, "%"PRId64, (int64_t)v);
 +    return buf;
 +}
 +
 +#define d2istr(v) double2int64str((char[BUF_SIZE]){0}, v)
 +
 +static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *frame)
 +{
 +    SetPTSContext *setpts = inlink->dst->priv;
 +    int64_t in_pts = frame->pts;
 +    double d;
 +
 +    if (isnan(setpts->var_values[VAR_STARTPTS])) {
 +        setpts->var_values[VAR_STARTPTS] = TS2D(frame->pts);
 +        setpts->var_values[VAR_STARTT  ] = TS2T(frame->pts, inlink->time_base);
 +    }
 +    setpts->var_values[VAR_PTS       ] = TS2D(frame->pts);
 +    setpts->var_values[VAR_T         ] = TS2T(frame->pts, inlink->time_base);
 +    setpts->var_values[VAR_POS       ] = frame->pos == -1 ? NAN : frame->pos;
++    setpts->var_values[VAR_RTCTIME   ] = av_gettime();
 +
 +    switch (inlink->type) {
 +    case AVMEDIA_TYPE_VIDEO:
 +        setpts->var_values[VAR_INTERLACED] = frame->video->interlaced;
 +        break;
 +
 +    case AVMEDIA_TYPE_AUDIO:
 +        setpts->var_values[VAR_NB_SAMPLES] = frame->audio->nb_samples;
 +        break;
 +    }
 +
 +    d = av_expr_eval(setpts->expr, setpts->var_values, NULL);
 +
 +    av_log(inlink->dst, AV_LOG_DEBUG,
 +           "N:%"PRId64" PTS:%s T:%f POS:%s",
 +           (int64_t)setpts->var_values[VAR_N],
 +           d2istr(setpts->var_values[VAR_PTS]),
 +           setpts->var_values[VAR_T],
 +           d2istr(setpts->var_values[VAR_POS]));
 +    switch (inlink->type) {
 +    case AVMEDIA_TYPE_VIDEO:
 +        av_log(inlink->dst, AV_LOG_DEBUG, " INTERLACED:%"PRId64,
 +               (int64_t)setpts->var_values[VAR_INTERLACED]);
 +        break;
 +    case AVMEDIA_TYPE_AUDIO:
 +        av_log(inlink->dst, AV_LOG_DEBUG, " NB_SAMPLES:%"PRId64" NB_CONSUMED_SAMPLES:%"PRId64,
 +               (int64_t)setpts->var_values[VAR_NB_SAMPLES],
 +               (int64_t)setpts->var_values[VAR_NB_CONSUMED_SAMPLES]);
 +        break;
 +    }
 +    av_log(inlink->dst, AV_LOG_DEBUG, " -> PTS:%s T:%f\n", d2istr(d), TS2T(d, inlink->time_base));
 +
 +    frame->pts = D2TS(d);
 +
 +    setpts->var_values[VAR_PREV_INPTS ] = TS2D(in_pts);
 +    setpts->var_values[VAR_PREV_INT   ] = TS2T(in_pts, inlink->time_base);
 +    setpts->var_values[VAR_PREV_OUTPTS] = TS2D(frame->pts);
 +    setpts->var_values[VAR_PREV_OUTT]   = TS2T(frame->pts, inlink->time_base);
 +    setpts->var_values[VAR_N] += 1.0;
 +    if (setpts->type == AVMEDIA_TYPE_AUDIO) {
 +        setpts->var_values[VAR_NB_CONSUMED_SAMPLES] += frame->audio->nb_samples;
 +    }
 +    return ff_filter_frame(inlink->dst->outputs[0], frame);
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    SetPTSContext *setpts = ctx->priv;
 +    av_expr_free(setpts->expr);
 +    setpts->expr = NULL;
 +}
 +
 +#if CONFIG_ASETPTS_FILTER
 +static const AVFilterPad avfilter_af_asetpts_inputs[] = {
 +    {
 +        .name             = "default",
 +        .type             = AVMEDIA_TYPE_AUDIO,
 +        .get_audio_buffer = ff_null_get_audio_buffer,
 +        .config_props     = config_input,
 +        .filter_frame     = filter_frame,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad avfilter_af_asetpts_outputs[] = {
 +    {
 +        .name = "default",
 +        .type = AVMEDIA_TYPE_AUDIO,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_af_asetpts = {
 +    .name      = "asetpts",
 +    .description = NULL_IF_CONFIG_SMALL("Set PTS for the output audio frame."),
 +    .init      = init,
 +    .uninit    = uninit,
 +    .priv_size = sizeof(SetPTSContext),
 +    .inputs    = avfilter_af_asetpts_inputs,
 +    .outputs   = avfilter_af_asetpts_outputs,
 +};
 +#endif /* CONFIG_ASETPTS_FILTER */
 +
 +#if CONFIG_SETPTS_FILTER
 +static const AVFilterPad avfilter_vf_setpts_inputs[] = {
 +    {
 +        .name             = "default",
 +        .type             = AVMEDIA_TYPE_VIDEO,
 +        .get_video_buffer = ff_null_get_video_buffer,
 +        .config_props     = config_input,
 +        .filter_frame     = filter_frame,
 +    },
 +    { NULL }
 +};
 +
 +static const AVFilterPad avfilter_vf_setpts_outputs[] = {
 +    {
 +        .name = "default",
 +        .type = AVMEDIA_TYPE_VIDEO,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_vf_setpts = {
 +    .name      = "setpts",
 +    .description = NULL_IF_CONFIG_SMALL("Set PTS for the output video frame."),
 +    .init      = init,
 +    .uninit    = uninit,
 +
 +    .priv_size = sizeof(SetPTSContext),
 +
 +    .inputs    = avfilter_vf_setpts_inputs,
 +    .outputs   = avfilter_vf_setpts_outputs,
 +};
 +#endif /* CONFIG_SETPTS_FILTER */