Merge commit 'a42d6e6c4c19912b73cae8ca9133b4202667c303'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Apr 2013 01:38:34 +0000 (03:38 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Apr 2013 01:41:08 +0000 (03:41 +0200)
* commit 'a42d6e6c4c19912b73cae8ca9133b4202667c303':
  vsrc_movie: switch to an AVOptions-based system.

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

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

@@@ -6884,287 -2116,252 +6884,284 @@@ The expression which is evaluated into 
  
  @end table
  
 -The direction can assume the following values:
 +The value for @option{tb} is 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). Default value is "intb".
  
 -@table @samp
 -@item cclock_flip
 -Rotate by 90 degrees counterclockwise and vertically flip (default), that is:
 +@subsection Examples
 +
 +@itemize
 +@item
 +Set the timebase to 1/25:
  @example
 -L.R     L.l
 -. . ->  . .
 -l.r     R.r
 +settb=expr=1/25
 +@end example
 +
 +@item
 +Set the timebase to 1/10:
 +@example
 +settb=expr=0.1
  @end example
  
 -@item clock
 -Rotate by 90 degrees clockwise, that is:
 +@item
 +Set the timebase to 1001/1000:
  @example
 -L.R     l.L
 -. . ->  . .
 -l.r     r.R
 +settb=1+0.001
  @end example
  
 -@item cclock
 -Rotate by 90 degrees counterclockwise, that is:
 +@item
 +Set the timebase to 2*intb:
  @example
 -L.R     R.r
 -. . ->  . .
 -l.r     L.l
 +settb=2*intb
  @end example
  
 -@item clock_flip
 -Rotate by 90 degrees clockwise and vertically flip, that is:
 +@item
 +Set the default timebase value:
  @example
 -L.R     r.R
 -. . ->  . .
 -l.r     l.L
 +settb=AVTB
  @end example
 -@end table
 +@end itemize
  
 -@section unsharp
 +@section concat
  
 -Sharpen or blur the input video.
 +Concatenate audio and video streams, joining them together one after the
 +other.
  
 -It accepts the following parameters:
 +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.
  
 +The filter accepts the following named parameters:
  @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 n
 +Set the number of segments. Default is 2.
  
 -@item luma_msize_y
 -Set the luma matrix vertical size. It can be an integer between 3
 -and 13, default value is 5.
 +@item v
 +Set the number of output video streams, that is also the number of video
 +streams in each segment. Default is 1.
  
 -@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 a
 +Set the number of output audio streams, that is also the number of video
 +streams in each segment. Default is 0.
  
 -@item chroma_msize_x
 -Set the chroma matrix horizontal size. It can be an integer between 3
 -and 13, default value is 5.
 +@item unsafe
 +Activate unsafe mode: do not fail if segments have a different format.
  
 -@item chroma_msize_y
 -Set the chroma matrix vertical size. It can be an integer between 3
 -and 13, default value is 5.
 +@end table
  
 -@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 has @var{v}+@var{a} outputs: first @var{v} video outputs, then
 +@var{a} audio outputs.
  
 -@end table
 +There are @var{n}x(@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.
  
 -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'.
 +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.
  
 -@example
 -# Strong luma sharpen effect parameters
 -unsharp=luma_msize_x=7:luma_msize_y=7:luma_amount=2.5
 +For this filter to work correctly, all segments must start at timestamp 0.
  
 -# Strong blur of both luma and chroma parameters
 -unsharp=7:7:-2:7:7:-2
 +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.
  
 -# Use the default values with @command{avconv}
 -./avconv -i in.avi -vf "unsharp" out.mp4
 -@end example
 +Different frame rates are acceptable but will result in variable frame rate
 +at output; be sure to configure the output file to handle it.
  
 -@section vflip
 +@subsection Examples
  
 -Flip the input video vertically.
 +@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
 +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
  
 +@item
 +Concatenate two parts, handling audio and video separately, using the
 +(a)movie sources, and adjusting the resolution:
  @example
 -./avconv -i in.avi -vf "vflip" out.avi
 +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 yadif
 +@end itemize
  
 -Deinterlace the input video ("yadif" means "yet another deinterlacing
 -filter").
 +@section showspectrum
  
 -This filter accepts the following options:
 +Convert input audio to a video output, representing the audio frequency
 +spectrum.
 +
 +The filter accepts the following options:
  
  @table @option
 +@item size, s
 +Specify the video size for the output. Default value is @code{640x512}.
 +
 +@item slide
 +Specify if the spectrum should slide along the window. Default value is
 +@code{0}.
  
  @item mode
 -The interlacing mode to adopt, accepts one of the following values:
 +Specify display mode.
  
 -@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
 +It accepts the following values:
 +@table @samp
 +@item combined
 +all channels are displayed in the same row
 +@item separate
 +all channels are displayed in separate rows
  @end table
  
 -Default value is 0.
 +Default value is @samp{combined}.
  
 -@item parity
 -The picture field parity assumed for the input interlaced video, accepts one of
 -the following values:
 +@item color
 +Specify display color mode.
  
 -@table @option
 -@item 0
 -assume top field first
 -@item 1
 -assume bottom field first
 -@item -1
 -enable automatic detection
 +It accepts the following values:
 +@table @samp
 +@item channel
 +each channel is displayed in a separate color
 +@item intensity
 +each channel is is displayed using the same color scheme
  @end table
  
 -Default value is -1.
 -If interlacing is unknown or decoder does not export this information,
 -top field first will be assumed.
 +Default value is @samp{channel}.
  
 -@item auto
 -Whether deinterlacer should trust the interlaced flag and only deinterlace
 -frames marked as interlaced
 +@item scale
 +Specify scale used for calculating intensity color values.
  
 -@table @option
 -@item 0
 -deinterlace all frames
 -@item 1
 -only deinterlace frames marked as interlaced
 +It accepts the following values:
 +@table @samp
 +@item lin
 +linear
 +@item sqrt
 +square root, default
 +@item cbrt
 +cubic root
 +@item log
 +logarithmic
  @end table
  
 -Default value is 0.
 +Default value is @samp{sqrt}.
  
 +@item saturation
 +Set saturation modifier for displayed colors. Negative values provide
 +alternative color scheme. @code{0} is no saturation at all.
 +Saturation must be in [-10.0, 10.0] range.
 +Default value is @code{1}.
  @end table
  
 -@c man end VIDEO FILTERS
 -
 -@chapter Video Sources
 -@c man begin VIDEO SOURCES
 +The usage is very similar to the showwaves filter; see the examples in that
 +section.
  
 -Below is a description of the currently available video sources.
 +@subsection Examples
  
 -@section buffer
 +@itemize
 +@item
 +Large window with logarithmic color scaling:
 +@example
 +showspectrum=s=1280x480:scale=log
 +@end example
  
 -Buffer video frames, and make them available to the filter chain.
 +@item
 +Complete example for a colored and sliding spectrum per channel using @command{ffplay}:
 +@example
 +ffplay -f lavfi 'amovie=input.mp3, asplit [a][out1];
 +             [a] showspectrum=mode=separate:color=intensity:slide=1:scale=cbrt [out0]'
 +@end example
 +@end itemize
  
 -This source is mainly intended for a programmatic use, in particular
 -through the interface defined in @file{libavfilter/vsrc_buffer.h}.
 +@section showwaves
  
 -This filter accepts the following parameters:
 +Convert input audio to a video output, representing the samples waves.
  
 +The filter accepts the following named parameters:
  @table @option
 +@item mode
 +Set display mode.
  
 -@item width
 -Input video width.
 +Available values are:
 +@table @samp
 +@item point
 +Draw a point for each sample.
  
 -@item height
 -Input video height.
 +@item line
 +Draw a vertical line for each sample.
 +@end table
  
 -@item pix_fmt
 -Name of the input video pixel format.
 +Default value is @code{point}.
  
 -@item time_base
 -The time base used for input timestamps.
 +@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 sar
 -Sample (pixel) aspect ratio of the input video.
 +@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:
 +@subsection Examples
 +
 +@itemize
 +@item
 +Output the input file audio and the corresponding video representation
 +at the same time:
  @example
 -buffer=width=320:height=240:pix_fmt=yuv410p:time_base=1/24:sar=1
 +amovie=a.mp3,asplit[out0],showwaves[out1]
  @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).
 -
 -@section color
 -
 -Provide an uniformly colored input.
 -
 -It accepts the following parameters:
 -
 -@table @option
 -
 -@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".
 +@item
 +Create a synthetic signal and show it with showwaves, forcing a
 +frame rate of 30 frames per second:
 +@example
 +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
  
 -@item 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".
 +@c man end MULTIMEDIA FILTERS
  
 -@item framerate
 -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".
 +@chapter Multimedia Sources
 +@c man begin MULTIMEDIA SOURCES
  
 -@end table
 +Below is a description of the currently available multimedia sources.
  
 -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".
 +@section amovie
  
 -@example
 -"color=red@@0.2:qcif:10 [color]; [in][color] overlay [out]"
 -@end example
 +This is the same as @ref{movie} source, except it selects an audio
 +stream by default.
  
 +@anchor{movie}
  @section movie
  
 -Read a video stream from a movie container.
 -
 -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.
 +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
- a file but also a device or a stream accessed through some protocol),
- and @var{options} is an optional sequence of @var{key}=@var{value}
- pairs, separated by ":".
- The description of the accepted options follows.
+ This filter accepts the following options:
  
  @table @option
 -
+ @item filename
+ The name of the resource to read (not necessarily a file but also a device or a
+ stream accessed through some protocol).
  
  @item format_name, f
  Specifies the format assumed for the movie to read, and can be either
@@@ -655,106 -479,8 +655,108 @@@ int avfilter_init_filter(AVFilterContex
      AVDictionary *options = NULL;
      AVDictionaryEntry *e;
      int ret=0;
 +    int anton_options =
 +        !strcmp(filter->filter->name,  "allpass"   ) ||
 +        !strcmp(filter->filter->name,  "afade"     ) ||
 +        !strcmp(filter->filter->name,  "aformat") ||
 +        !strcmp(filter->filter->name,  "amix"      ) ||
 +        !strcmp(filter->filter->name,  "apad"      ) ||
 +        !strcmp(filter->filter->name,  "aphaser"   ) ||
 +        !strcmp(filter->filter->name,  "asplit"    ) ||
 +        !strcmp(filter->filter->name,  "ass")     ||
 +        !strcmp(filter->filter->name,  "asyncts"   ) ||
 +        !strcmp(filter->filter->name,  "bandpass"  ) ||
 +        !strcmp(filter->filter->name,  "bandreject") ||
 +        !strcmp(filter->filter->name,  "bass"      ) ||
 +        !strcmp(filter->filter->name,  "biquad"    ) ||
 +        !strcmp(filter->filter->name,  "blackframe") ||
 +        !strcmp(filter->filter->name,  "blend"     ) ||
 +        !strcmp(filter->filter->name,  "boxblur"   ) ||
 +        !strcmp(filter->filter->name,  "cellauto") ||
 +        !strcmp(filter->filter->name,  "channelmap") ||
 +        !strcmp(filter->filter->name,  "channelsplit") ||
 +        !strcmp(filter->filter->name,  "color"     ) ||
 +        !strcmp(filter->filter->name,  "colormatrix") ||
 +        !strcmp(filter->filter->name,  "crop"      ) ||
 +        !strcmp(filter->filter->name,  "cropdetect") ||
 +        !strcmp(filter->filter->name,  "curves"    ) ||
 +        !strcmp(filter->filter->name,  "decimate"  ) ||
 +        !strcmp(filter->filter->name,  "delogo"    ) ||
 +        !strcmp(filter->filter->name,  "drawbox"   ) ||
 +        !strcmp(filter->filter->name,  "drawtext"  ) ||
 +        !strcmp(filter->filter->name,  "ebur128"   ) ||
 +        !strcmp(filter->filter->name,  "edgedetect") ||
 +        !strcmp(filter->filter->name,  "equalizer" ) ||
 +        !strcmp(filter->filter->name,  "fade"      ) ||
 +        !strcmp(filter->filter->name,  "field"     ) ||
 +        !strcmp(filter->filter->name,  "fieldorder") ||
 +        !strcmp(filter->filter->name,  "fps"       ) ||
 +        !strcmp(filter->filter->name,  "framestep" ) ||
 +        !strcmp(filter->filter->name,  "frei0r"    ) ||
 +        !strcmp(filter->filter->name,  "frei0r_src") ||
 +        !strcmp(filter->filter->name,  "geq"       ) ||
 +        !strcmp(filter->filter->name, "gradfun"    ) ||
 +        !strcmp(filter->filter->name, "highpass"  ) ||
 +        !strcmp(filter->filter->name, "histeq"     ) ||
 +        !strcmp(filter->filter->name, "histogram"  ) ||
 +        !strcmp(filter->filter->name, "hqdn3d"     ) ||
 +        !strcmp(filter->filter->name, "idet"       ) ||
 +        !strcmp(filter->filter->name,  "il"        ) ||
 +        !strcmp(filter->filter->name,  "join"      ) ||
 +        !strcmp(filter->filter->name,  "kerndeint" ) ||
 +        !strcmp(filter->filter->name, "ocv"        ) ||
 +        !strcmp(filter->filter->name, "life"       ) ||
 +        !strcmp(filter->filter->name, "lut"        ) ||
 +        !strcmp(filter->filter->name, "lutyuv"     ) ||
 +        !strcmp(filter->filter->name, "lutrgb"     ) ||
 +        !strcmp(filter->filter->name, "lowpass"   ) ||
 +        !strcmp(filter->filter->name, "mandelbrot" ) ||
 +        !strcmp(filter->filter->name, "mptestsrc"  ) ||
++        !strcmp(filter->filter->name, "movie"      ) ||
++        !strcmp(filter->filter->name, "amovie"     ) ||
 +        !strcmp(filter->filter->name, "negate"     ) ||
 +        !strcmp(filter->filter->name, "noise"      ) ||
 +        !strcmp(filter->filter->name, "nullsrc"    ) ||
 +        !strcmp(filter->filter->name, "overlay"    ) ||
 +        !strcmp(filter->filter->name, "pad"        ) ||
 +        !strcmp(filter->filter->name,   "format") ||
 +        !strcmp(filter->filter->name, "noformat") ||
 +        !strcmp(filter->filter->name, "perms")  ||
 +        !strcmp(filter->filter->name, "pp"   )  ||
 +        !strcmp(filter->filter->name, "aperms") ||
 +        !strcmp(filter->filter->name, "resample") ||
 +        !strcmp(filter->filter->name, "setpts"       ) ||
 +        !strcmp(filter->filter->name, "settb"        ) ||
 +        !strcmp(filter->filter->name, "showspectrum") ||
 +        !strcmp(filter->filter->name, "silencedetect") ||
 +        !strcmp(filter->filter->name, "smartblur") ||
 +        !strcmp(filter->filter->name, "split"    ) ||
 +        !strcmp(filter->filter->name, "stereo3d" ) ||
 +        !strcmp(filter->filter->name, "subtitles") ||
 +        !strcmp(filter->filter->name, "thumbnail") ||
 +        !strcmp(filter->filter->name, "transpose") ||
 +        !strcmp(filter->filter->name, "treble"    ) ||
 +        !strcmp(filter->filter->name, "unsharp"  ) ||
 +//         !strcmp(filter->filter->name, "scale"      ) ||
 +        !strcmp(filter->filter->name, "select") ||
 +        !strcmp(filter->filter->name, "volume"   ) ||
 +        !strcmp(filter->filter->name, "yadif"    ) ||
 +        0
 +        ;
 +
 +    if (filter->filter->shorthand) {
 +        av_assert0(filter->priv);
 +        av_assert0(filter->filter->priv_class);
 +        *(const AVClass **)filter->priv = filter->filter->priv_class;
 +        av_opt_set_defaults(filter->priv);
 +        ret = av_opt_set_from_string(filter->priv, args,
 +                                     filter->filter->shorthand, "=", ":");
 +        if (ret < 0)
 +            return ret;
 +        args = NULL;
 +    }
  
 -    if (args && *args && filter->filter->priv_class) {
 +    if (anton_options && args && *args && filter->filter->priv_class) {
  #if FF_API_OLD_FILTER_OPTS
          if (!strcmp(filter->filter->name, "scale") &&
              strchr(args, ':') < strchr(args, '=')) {
index 455ebe0,0000000..c409b83
mode 100644,000000..100644
--- /dev/null
@@@ -1,620 -1,0 +1,609 @@@
- #define F AV_OPT_FLAG_FILTERING_PARAM
 +/*
 + * 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
 + * movie video source
 + *
 + * @todo use direct rendering (no allocation of a new frame)
 + * @todo support a PTS correction mechanism
 + */
 +
 +/* #define DEBUG */
 +
 +#include <float.h>
 +#include "libavutil/avstring.h"
 +#include "libavutil/avassert.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/imgutils.h"
 +#include "libavutil/timestamp.h"
 +#include "libavformat/avformat.h"
 +#include "audio.h"
 +#include "avcodec.h"
 +#include "avfilter.h"
 +#include "formats.h"
 +#include "internal.h"
 +#include "video.h"
 +
 +typedef struct {
 +    AVStream *st;
 +    int done;
 +} MovieStream;
 +
 +typedef struct {
 +    /* common A/V fields */
 +    const AVClass *class;
 +    int64_t seek_point;   ///< seekpoint in microseconds
 +    double seek_point_d;
 +    char *format_name;
 +    char *file_name;
 +    char *stream_specs; /**< user-provided list of streams, separated by + */
 +    int stream_index; /**< for compatibility */
 +    int loop_count;
 +
 +    AVFormatContext *format_ctx;
 +    int eof;
 +    AVPacket pkt, pkt0;
 +    AVFrame *frame;   ///< video frame to store the decoded images in
 +
 +    int max_stream_index; /**< max stream # actually used for output */
 +    MovieStream *st; /**< array of all streams, one per output */
 +    int *out_index; /**< stream number -> output number map, or -1 */
 +} MovieContext;
 +
 +#define OFFSET(x) offsetof(MovieContext, x)
- {"format_name",  "set format name",         OFFSET(format_name),  AV_OPT_TYPE_STRING, {.str =  0},  CHAR_MIN, CHAR_MAX, F },
- {"f",            "set format name",         OFFSET(format_name),  AV_OPT_TYPE_STRING, {.str =  0},  CHAR_MIN, CHAR_MAX, F },
- {"streams",      "set streams",             OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str =  0},  CHAR_MAX, CHAR_MAX, F },
- {"s",            "set streams",             OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str =  0},  CHAR_MAX, CHAR_MAX, F },
- {"si",           "set stream index",        OFFSET(stream_index), AV_OPT_TYPE_INT,    {.i64 = -1},  -1,       INT_MAX, F },
- {"stream_index", "set stream index",        OFFSET(stream_index), AV_OPT_TYPE_INT,    {.i64 = -1},  -1,       INT_MAX, F },
- {"seek_point",   "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, {.dbl =  0},  0,        (INT64_MAX-1) / 1000000, F },
- {"sp",           "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, {.dbl =  0},  0,        (INT64_MAX-1) / 1000000, F },
- {"loop",         "set loop count",          OFFSET(loop_count),   AV_OPT_TYPE_INT,    {.i64 =  1},  0,        INT_MAX, F },
- {NULL},
++#define FLAGS AV_OPT_FLAG_FILTERING_PARAM
 +
 +static const AVOption movie_options[]= {
- static av_cold int movie_common_init(AVFilterContext *ctx, const char *args, const AVClass *class)
++    { "filename",     NULL,                      OFFSET(file_name),    AV_OPT_TYPE_STRING,                                    .flags = FLAGS },
++    { "format_name",  "set format name",         OFFSET(format_name),  AV_OPT_TYPE_STRING,                                    .flags = FLAGS },
++    { "f",            "set format name",         OFFSET(format_name),  AV_OPT_TYPE_STRING,                                    .flags = FLAGS },
++    { "stream_index", "set stream index",        OFFSET(stream_index), AV_OPT_TYPE_INT,    { .i64 = -1 }, -1, INT_MAX,                 FLAGS  },
++    { "si",           "set stream index",        OFFSET(stream_index), AV_OPT_TYPE_INT,    { .i64 = -1 }, -1, INT_MAX,                 FLAGS  },
++    { "seek_point",   "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl =  0 },  0, (INT64_MAX-1) / 1000000, FLAGS },
++    { "sp",           "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl =  0 },  0, (INT64_MAX-1) / 1000000, FLAGS },
++    { "streams",      "set streams",             OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str =  0},  CHAR_MAX, CHAR_MAX, FLAGS },
++    { "s",            "set streams",             OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str =  0},  CHAR_MAX, CHAR_MAX, FLAGS },
++    { "loop",         "set loop count",          OFFSET(loop_count),   AV_OPT_TYPE_INT,    {.i64 =  1},  0,        INT_MAX, FLAGS },
++    { NULL },
 +};
 +
 +static int movie_config_output_props(AVFilterLink *outlink);
 +static int movie_request_frame(AVFilterLink *outlink);
 +
 +static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
 +{
 +    int i, ret, already = 0, stream_id = -1;
 +    char type_char, dummy;
 +    AVStream *found = NULL;
 +    enum AVMediaType type;
 +
 +    ret = sscanf(spec, "d%[av]%d%c", &type_char, &stream_id, &dummy);
 +    if (ret >= 1 && ret <= 2) {
 +        type = type_char == 'v' ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
 +        ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
 +        if (ret < 0) {
 +            av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
 +                   av_get_media_type_string(type), stream_id);
 +            return NULL;
 +        }
 +        return avf->streams[ret];
 +    }
 +    for (i = 0; i < avf->nb_streams; i++) {
 +        ret = avformat_match_stream_specifier(avf, avf->streams[i], spec);
 +        if (ret < 0) {
 +            av_log(log, AV_LOG_ERROR,
 +                   "Invalid stream specifier \"%s\"\n", spec);
 +            return NULL;
 +        }
 +        if (!ret)
 +            continue;
 +        if (avf->streams[i]->discard != AVDISCARD_ALL) {
 +            already++;
 +            continue;
 +        }
 +        if (found) {
 +            av_log(log, AV_LOG_WARNING,
 +                   "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
 +            break;
 +        }
 +        found = avf->streams[i];
 +    }
 +    if (!found) {
 +        av_log(log, AV_LOG_WARNING, "Stream specifier \"%s\" %s\n", spec,
 +               already ? "matched only already used streams" :
 +                         "did not match any stream");
 +        return NULL;
 +    }
 +    if (found->codec->codec_type != AVMEDIA_TYPE_VIDEO &&
 +        found->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
 +        av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
 +               "currently unsupported by libavfilter\n", spec,
 +               av_get_media_type_string(found->codec->codec_type));
 +        return NULL;
 +    }
 +    return found;
 +}
 +
 +static int open_stream(void *log, MovieStream *st)
 +{
 +    AVCodec *codec;
 +    int ret;
 +
 +    codec = avcodec_find_decoder(st->st->codec->codec_id);
 +    if (!codec) {
 +        av_log(log, AV_LOG_ERROR, "Failed to find any codec\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    st->st->codec->refcounted_frames = 1;
 +
 +    if ((ret = avcodec_open2(st->st->codec, codec, NULL)) < 0) {
 +        av_log(log, AV_LOG_ERROR, "Failed to open codec\n");
 +        return ret;
 +    }
 +
 +    return 0;
 +}
 +
 +static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
 +{
 +    AVCodecContext *dec_ctx = st->st->codec;
 +    char buf[256];
 +    int64_t chl = av_get_default_channel_layout(dec_ctx->channels);
 +
 +    if (!chl) {
 +        av_log(log_ctx, AV_LOG_ERROR,
 +               "Channel layout is not set in stream %d, and could not "
 +               "be guessed from the number of channels (%d)\n",
 +               st_index, dec_ctx->channels);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    av_get_channel_layout_string(buf, sizeof(buf), dec_ctx->channels, chl);
 +    av_log(log_ctx, AV_LOG_WARNING,
 +           "Channel layout is not set in output stream %d, "
 +           "guessed channel layout is '%s'\n",
 +           st_index, buf);
 +    dec_ctx->channel_layout = chl;
 +    return 0;
 +}
 +
-     movie->class = class;
-     av_opt_set_defaults(movie);
-     if (args) {
-         movie->file_name = av_get_token(&args, ":");
-         if (!movie->file_name)
-             return AVERROR(ENOMEM);
-     }
-     if (!args || !*movie->file_name) {
++static av_cold int movie_common_init(AVFilterContext *ctx)
 +{
 +    MovieContext *movie = ctx->priv;
 +    AVInputFormat *iformat = NULL;
 +    int64_t timestamp;
 +    int nb_streams, ret, i;
 +    char default_streams[16], *stream_specs, *spec, *cursor;
 +    char name[16];
 +    AVStream *st;
 +
-     if (*args++ == ':' && (ret = av_set_options_string(movie, args, "=", ":")) < 0)
-         return ret;
++    if (!*movie->file_name) {
 +        av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
 +        return AVERROR(EINVAL);
 +    }
 +
-     av_opt_free(movie);
 +    movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
 +
 +    stream_specs = movie->stream_specs;
 +    if (!stream_specs) {
 +        snprintf(default_streams, sizeof(default_streams), "d%c%d",
 +                 !strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
 +                 movie->stream_index);
 +        stream_specs = default_streams;
 +    }
 +    for (cursor = stream_specs, nb_streams = 1; *cursor; cursor++)
 +        if (*cursor == '+')
 +            nb_streams++;
 +
 +    if (movie->loop_count != 1 && nb_streams != 1) {
 +        av_log(ctx, AV_LOG_ERROR,
 +               "Loop with several streams is currently unsupported\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    av_register_all();
 +
 +    // Try to find the movie format (container)
 +    iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
 +
 +    movie->format_ctx = NULL;
 +    if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
 +        av_log(ctx, AV_LOG_ERROR,
 +               "Failed to avformat_open_input '%s'\n", movie->file_name);
 +        return ret;
 +    }
 +    if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
 +        av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
 +
 +    // if seeking requested, we execute it
 +    if (movie->seek_point > 0) {
 +        timestamp = movie->seek_point;
 +        // add the stream start time, should it exist
 +        if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
 +            if (timestamp > INT64_MAX - movie->format_ctx->start_time) {
 +                av_log(ctx, AV_LOG_ERROR,
 +                       "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
 +                       movie->file_name, movie->format_ctx->start_time, movie->seek_point);
 +                return AVERROR(EINVAL);
 +            }
 +            timestamp += movie->format_ctx->start_time;
 +        }
 +        if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
 +            av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
 +                   movie->file_name, timestamp);
 +            return ret;
 +        }
 +    }
 +
 +    for (i = 0; i < movie->format_ctx->nb_streams; i++)
 +        movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
 +
 +    movie->st = av_calloc(nb_streams, sizeof(*movie->st));
 +    if (!movie->st)
 +        return AVERROR(ENOMEM);
 +
 +    for (i = 0; i < nb_streams; i++) {
 +        spec = av_strtok(stream_specs, "+", &cursor);
 +        if (!spec)
 +            return AVERROR_BUG;
 +        stream_specs = NULL; /* for next strtok */
 +        st = find_stream(ctx, movie->format_ctx, spec);
 +        if (!st)
 +            return AVERROR(EINVAL);
 +        st->discard = AVDISCARD_DEFAULT;
 +        movie->st[i].st = st;
 +        movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
 +    }
 +    if (av_strtok(NULL, "+", &cursor))
 +        return AVERROR_BUG;
 +
 +    movie->out_index = av_calloc(movie->max_stream_index + 1,
 +                                 sizeof(*movie->out_index));
 +    if (!movie->out_index)
 +        return AVERROR(ENOMEM);
 +    for (i = 0; i <= movie->max_stream_index; i++)
 +        movie->out_index[i] = -1;
 +    for (i = 0; i < nb_streams; i++)
 +        movie->out_index[movie->st[i].st->index] = i;
 +
 +    for (i = 0; i < nb_streams; i++) {
 +        AVFilterPad pad = { 0 };
 +        snprintf(name, sizeof(name), "out%d", i);
 +        pad.type          = movie->st[i].st->codec->codec_type;
 +        pad.name          = av_strdup(name);
 +        pad.config_props  = movie_config_output_props;
 +        pad.request_frame = movie_request_frame;
 +        ff_insert_outpad(ctx, i, &pad);
 +        ret = open_stream(ctx, &movie->st[i]);
 +        if (ret < 0)
 +            return ret;
 +        if ( movie->st[i].st->codec->codec->type == AVMEDIA_TYPE_AUDIO &&
 +            !movie->st[i].st->codec->channel_layout) {
 +            ret = guess_channel_layout(&movie->st[i], i, ctx);
 +            if (ret < 0)
 +                return ret;
 +        }
 +    }
 +
 +    av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
 +           movie->seek_point, movie->format_name, movie->file_name,
 +           movie->stream_index);
 +
 +    return 0;
 +}
 +
 +static av_cold void movie_uninit(AVFilterContext *ctx)
 +{
 +    MovieContext *movie = ctx->priv;
 +    int i;
 +
 +    for (i = 0; i < ctx->nb_outputs; i++) {
 +        av_freep(&ctx->output_pads[i].name);
 +        if (movie->st[i].st)
 +            avcodec_close(movie->st[i].st->codec);
 +    }
-     return movie_common_init(ctx, args, &movie_class);
 +    av_freep(&movie->file_name);
 +    av_freep(&movie->st);
 +    av_freep(&movie->out_index);
 +    av_frame_free(&movie->frame);
 +    if (movie->format_ctx)
 +        avformat_close_input(&movie->format_ctx);
 +}
 +
 +static int movie_query_formats(AVFilterContext *ctx)
 +{
 +    MovieContext *movie = ctx->priv;
 +    int list[] = { 0, -1 };
 +    int64_t list64[] = { 0, -1 };
 +    int i;
 +
 +    for (i = 0; i < ctx->nb_outputs; i++) {
 +        MovieStream *st = &movie->st[i];
 +        AVCodecContext *c = st->st->codec;
 +        AVFilterLink *outlink = ctx->outputs[i];
 +
 +        switch (c->codec_type) {
 +        case AVMEDIA_TYPE_VIDEO:
 +            list[0] = c->pix_fmt;
 +            ff_formats_ref(ff_make_format_list(list), &outlink->in_formats);
 +            break;
 +        case AVMEDIA_TYPE_AUDIO:
 +            list[0] = c->sample_fmt;
 +            ff_formats_ref(ff_make_format_list(list), &outlink->in_formats);
 +            list[0] = c->sample_rate;
 +            ff_formats_ref(ff_make_format_list(list), &outlink->in_samplerates);
 +            list64[0] = c->channel_layout;
 +            ff_channel_layouts_ref(avfilter_make_format64_list(list64),
 +                                   &outlink->in_channel_layouts);
 +            break;
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static int movie_config_output_props(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    MovieContext *movie  = ctx->priv;
 +    unsigned out_id = FF_OUTLINK_IDX(outlink);
 +    MovieStream *st = &movie->st[out_id];
 +    AVCodecContext *c = st->st->codec;
 +
 +    outlink->time_base = st->st->time_base;
 +
 +    switch (c->codec_type) {
 +    case AVMEDIA_TYPE_VIDEO:
 +        outlink->w          = c->width;
 +        outlink->h          = c->height;
 +        outlink->frame_rate = st->st->r_frame_rate;
 +        break;
 +    case AVMEDIA_TYPE_AUDIO:
 +        break;
 +    }
 +
 +    return 0;
 +}
 +
 +static char *describe_frame_to_str(char *dst, size_t dst_size,
 +                                    AVFrame *frame,
 +                                    AVFilterLink *link)
 +{
 +    switch (frame->type) {
 +    case AVMEDIA_TYPE_VIDEO:
 +        snprintf(dst, dst_size,
 +                 "video pts:%s time:%s size:%dx%d aspect:%d/%d",
 +                 av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
 +                 frame->width, frame->height,
 +                 frame->sample_aspect_ratio.num,
 +                 frame->sample_aspect_ratio.den);
 +                 break;
 +    case AVMEDIA_TYPE_AUDIO:
 +        snprintf(dst, dst_size,
 +                 "audio pts:%s time:%s samples:%d",
 +                 av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
 +                 frame->nb_samples);
 +                 break;
 +    default:
 +        snprintf(dst, dst_size, "%s BUG", av_get_media_type_string(frame->type));
 +        break;
 +    }
 +    return dst;
 +}
 +
 +#define describe_frameref(f, link) \
 +    describe_frame_to_str((char[1024]){0}, 1024, f, link)
 +
 +static int rewind_file(AVFilterContext *ctx)
 +{
 +    MovieContext *movie = ctx->priv;
 +    int64_t timestamp = movie->seek_point;
 +    int ret, i;
 +
 +    if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
 +        timestamp += movie->format_ctx->start_time;
 +    ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
 +    if (ret < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
 +        movie->loop_count = 1; /* do not try again */
 +        return ret;
 +    }
 +
 +    for (i = 0; i < ctx->nb_outputs; i++) {
 +        avcodec_flush_buffers(movie->st[i].st->codec);
 +        movie->st[i].done = 0;
 +    }
 +    movie->eof = 0;
 +    return 0;
 +}
 +
 +/**
 + * Try to push a frame to the requested output.
 + *
 + * @param ctx     filter context
 + * @param out_id  number of output where a frame is wanted;
 + *                if the frame is read from file, used to set the return value;
 + *                if the codec is being flushed, flush the corresponding stream
 + * @return  1 if a frame was pushed on the requested output,
 + *          0 if another attempt is possible,
 + *          <0 AVERROR code
 + */
 +static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
 +{
 +    MovieContext *movie = ctx->priv;
 +    AVPacket *pkt = &movie->pkt;
 +    MovieStream *st;
 +    int ret, got_frame = 0, pkt_out_id;
 +    AVFilterLink *outlink;
 +
 +    if (!pkt->size) {
 +        if (movie->eof) {
 +            if (movie->st[out_id].done) {
 +                if (movie->loop_count != 1) {
 +                    ret = rewind_file(ctx);
 +                    if (ret < 0)
 +                        return ret;
 +                    movie->loop_count -= movie->loop_count > 1;
 +                    av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
 +                    return 0; /* retry */
 +                }
 +                return AVERROR_EOF;
 +            }
 +            pkt->stream_index = movie->st[out_id].st->index;
 +            /* packet is already ready for flushing */
 +        } else {
 +            ret = av_read_frame(movie->format_ctx, &movie->pkt0);
 +            if (ret < 0) {
 +                av_init_packet(&movie->pkt0); /* ready for flushing */
 +                *pkt = movie->pkt0;
 +                if (ret == AVERROR_EOF) {
 +                    movie->eof = 1;
 +                    return 0; /* start flushing */
 +                }
 +                return ret;
 +            }
 +            *pkt = movie->pkt0;
 +        }
 +    }
 +
 +    pkt_out_id = pkt->stream_index > movie->max_stream_index ? -1 :
 +                 movie->out_index[pkt->stream_index];
 +    if (pkt_out_id < 0) {
 +        av_free_packet(&movie->pkt0);
 +        pkt->size = 0; /* ready for next run */
 +        pkt->data = NULL;
 +        return 0;
 +    }
 +    st = &movie->st[pkt_out_id];
 +    outlink = ctx->outputs[pkt_out_id];
 +
 +    movie->frame = av_frame_alloc();
 +    if (!movie->frame)
 +        return AVERROR(ENOMEM);
 +
 +    switch (st->st->codec->codec_type) {
 +    case AVMEDIA_TYPE_VIDEO:
 +        ret = avcodec_decode_video2(st->st->codec, movie->frame, &got_frame, pkt);
 +        break;
 +    case AVMEDIA_TYPE_AUDIO:
 +        ret = avcodec_decode_audio4(st->st->codec, movie->frame, &got_frame, pkt);
 +        break;
 +    default:
 +        ret = AVERROR(ENOSYS);
 +        break;
 +    }
 +    if (ret < 0) {
 +        av_log(ctx, AV_LOG_WARNING, "Decode error: %s\n", av_err2str(ret));
 +        av_frame_free(&movie->frame);
 +        return 0;
 +    }
 +    if (!ret)
 +        ret = pkt->size;
 +
 +    pkt->data += ret;
 +    pkt->size -= ret;
 +    if (pkt->size <= 0) {
 +        av_free_packet(&movie->pkt0);
 +        pkt->size = 0; /* ready for next run */
 +        pkt->data = NULL;
 +    }
 +    if (!got_frame) {
 +        if (!ret)
 +            st->done = 1;
 +        av_frame_free(&movie->frame);
 +        return 0;
 +    }
 +
 +    av_dlog(ctx, "movie_push_frame(): file:'%s' %s\n", movie->file_name,
 +            describe_frameref(movie->frame, outlink));
 +
 +    movie->frame->pts = av_frame_get_best_effort_timestamp(movie->frame);
 +    ret = ff_filter_frame(outlink, movie->frame);
 +    movie->frame = NULL;
 +
 +    if (ret < 0)
 +        return ret;
 +    return pkt_out_id == out_id;
 +}
 +
 +static int movie_request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    unsigned out_id = FF_OUTLINK_IDX(outlink);
 +    int ret;
 +
 +    while (1) {
 +        ret = movie_push_frame(ctx, out_id);
 +        if (ret)
 +            return FFMIN(ret, 0);
 +    }
 +}
 +
 +#if CONFIG_MOVIE_FILTER
 +
 +AVFILTER_DEFINE_CLASS(movie);
 +
 +static av_cold int movie_init(AVFilterContext *ctx, const char *args)
 +{
-     .priv_class = &movie_class,
++    return movie_common_init(ctx);
 +}
 +
 +AVFilter avfilter_avsrc_movie = {
 +    .name          = "movie",
 +    .description   = NULL_IF_CONFIG_SMALL("Read from a movie source."),
 +    .priv_size     = sizeof(MovieContext),
++    .priv_class    = &movie_class,
 +    .init          = movie_init,
 +    .uninit        = movie_uninit,
 +    .query_formats = movie_query_formats,
 +
 +    .inputs    = NULL,
 +    .outputs   = NULL,
-     return movie_common_init(ctx, args, &amovie_class);
 +};
 +
 +#endif  /* CONFIG_MOVIE_FILTER */
 +
 +#if CONFIG_AMOVIE_FILTER
 +
 +#define amovie_options movie_options
 +AVFILTER_DEFINE_CLASS(amovie);
 +
 +static av_cold int amovie_init(AVFilterContext *ctx, const char *args)
 +{
++    return movie_common_init(ctx);
 +}
 +
 +AVFilter avfilter_avsrc_amovie = {
 +    .name          = "amovie",
 +    .description   = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
 +    .priv_size     = sizeof(MovieContext),
 +    .init          = amovie_init,
 +    .uninit        = movie_uninit,
 +    .query_formats = movie_query_formats,
 +
 +    .inputs     = NULL,
 +    .outputs    = NULL,
 +    .priv_class = &amovie_class,
 +};
 +
 +#endif /* CONFIG_AMOVIE_FILTER */