Merge commit '4436f25a1682ada3f7226cb6fadf429946933161'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Oct 2012 13:41:56 +0000 (15:41 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Oct 2012 13:46:48 +0000 (15:46 +0200)
* commit '4436f25a1682ada3f7226cb6fadf429946933161':
  build: remove references to unused EXTRAOBJS variable
  lavfi: convert input/ouput list compound literals to named objects
  fate: add h263 obmc vsynth tests
  avconv: remove bogus warning when using avconv -h without parameter
  averror: explicitly define AVERROR_* values
  flashsv: propagate inflateReset() errors
  indeo4/5: remove constant parameter num_bands from wavelet recomposition
  mxfdec: return error if no segments are available in mxf_get_sorted_table_segments
  Double motion vector range for HPEL interlaced picture in proper place

Conflicts:
libavcodec/v210dec.h
libavfilter/af_aformat.c
libavfilter/af_amix.c
libavfilter/af_asyncts.c
libavfilter/af_channelmap.c
libavfilter/af_join.c
libavfilter/asrc_anullsrc.c
libavfilter/buffersrc.c
libavfilter/f_setpts.c
libavfilter/f_settb.c
libavfilter/fifo.c
libavfilter/src_movie.c
libavfilter/vf_ass.c
libavfilter/vf_blackframe.c
libavfilter/vf_boxblur.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_hflip.c
libavfilter/vf_overlay.c
libavfilter/vf_pad.c
libavfilter/vf_select.c
libavfilter/vf_transpose.c
libavfilter/vf_yadif.c
libavfilter/vsrc_testsrc.c
libavformat/mxfdec.c
libavutil/error.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
59 files changed:
1  2 
ffmpeg_opt.c
libavcodec/flashsv.c
libavcodec/ivi_common.c
libavcodec/ivi_dsp.c
libavcodec/ivi_dsp.h
libavcodec/vc1.c
libavcodec/vc1dec.c
libavfilter/af_aformat.c
libavfilter/af_amix.c
libavfilter/af_anull.c
libavfilter/af_asyncts.c
libavfilter/af_channelmap.c
libavfilter/af_channelsplit.c
libavfilter/af_join.c
libavfilter/asink_anullsink.c
libavfilter/asrc_anullsrc.c
libavfilter/buffersink.c
libavfilter/buffersrc.c
libavfilter/f_setpts.c
libavfilter/f_settb.c
libavfilter/fifo.c
libavfilter/split.c
libavfilter/vf_aspect.c
libavfilter/vf_blackframe.c
libavfilter/vf_boxblur.c
libavfilter/vf_copy.c
libavfilter/vf_crop.c
libavfilter/vf_cropdetect.c
libavfilter/vf_delogo.c
libavfilter/vf_drawbox.c
libavfilter/vf_drawtext.c
libavfilter/vf_fade.c
libavfilter/vf_fieldorder.c
libavfilter/vf_format.c
libavfilter/vf_fps.c
libavfilter/vf_frei0r.c
libavfilter/vf_gradfun.c
libavfilter/vf_hflip.c
libavfilter/vf_hqdn3d.c
libavfilter/vf_libopencv.c
libavfilter/vf_null.c
libavfilter/vf_overlay.c
libavfilter/vf_pad.c
libavfilter/vf_pixdesctest.c
libavfilter/vf_scale.c
libavfilter/vf_select.c
libavfilter/vf_showinfo.c
libavfilter/vf_slicify.c
libavfilter/vf_transpose.c
libavfilter/vf_unsharp.c
libavfilter/vf_vflip.c
libavfilter/vf_yadif.c
libavfilter/vsink_nullsink.c
libavfilter/vsrc_testsrc.c
libavformat/mxfdec.c
library.mak
tests/fate/vcodec.mak
tests/ref/fate/vsynth1-h263-obmc
tests/ref/fate/vsynth2-h263-obmc

diff --cc ffmpeg_opt.c
index 23dbb3e,0000000..fba7cb4
mode 100644,000000..100644
--- /dev/null
@@@ -1,2511 -1,0 +1,2511 @@@
-     if (opt) {
 +/*
 + * ffmpeg option parsing
 + *
 + * 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
 + */
 +
 +#include <stdint.h>
 +
 +#include "ffmpeg.h"
 +#include "cmdutils.h"
 +
 +#include "libavformat/avformat.h"
 +
 +#include "libavcodec/avcodec.h"
 +
 +#include "libavfilter/avfilter.h"
 +#include "libavfilter/avfiltergraph.h"
 +
 +#include "libavutil/audioconvert.h"
 +#include "libavutil/avassert.h"
 +#include "libavutil/avstring.h"
 +#include "libavutil/avutil.h"
 +#include "libavutil/intreadwrite.h"
 +#include "libavutil/fifo.h"
 +#include "libavutil/mathematics.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/parseutils.h"
 +#include "libavutil/pixdesc.h"
 +#include "libavutil/pixfmt.h"
 +
 +#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
 +{\
 +    int i, ret;\
 +    for (i = 0; i < o->nb_ ## name; i++) {\
 +        char *spec = o->name[i].specifier;\
 +        if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
 +            outvar = o->name[i].u.type;\
 +        else if (ret < 0)\
 +            exit(1);\
 +    }\
 +}
 +
 +#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
 +{\
 +    int i;\
 +    for (i = 0; i < o->nb_ ## name; i++) {\
 +        char *spec = o->name[i].specifier;\
 +        if (!strcmp(spec, mediatype))\
 +            outvar = o->name[i].u.type;\
 +    }\
 +}
 +char *vstats_filename;
 +
 +float audio_drift_threshold = 0.1;
 +float dts_delta_threshold   = 10;
 +float dts_error_threshold   = 3600*30;
 +
 +int audio_volume      = 256;
 +int audio_sync_method = 0;
 +int video_sync_method = VSYNC_AUTO;
 +int do_deinterlace    = 0;
 +int do_benchmark      = 0;
 +int do_benchmark_all  = 0;
 +int do_hex_dump       = 0;
 +int do_pkt_dump       = 0;
 +int copy_ts           = 0;
 +int copy_tb           = -1;
 +int debug_ts          = 0;
 +int exit_on_error     = 0;
 +int print_stats       = 1;
 +int qp_hist           = 0;
 +int stdin_interaction = 1;
 +int frame_bits_per_raw_sample = 0;
 +
 +
 +static int intra_only         = 0;
 +static int file_overwrite     = 0;
 +static int no_file_overwrite  = 0;
 +static int video_discard      = 0;
 +static int intra_dc_precision = 8;
 +static int do_psnr            = 0;
 +static int input_sync;
 +
 +void reset_options(OptionsContext *o, int is_input)
 +{
 +    const OptionDef *po = options;
 +    OptionsContext bak= *o;
 +    int i;
 +
 +    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
 +    while (po->name) {
 +        void *dst = (uint8_t*)o + po->u.off;
 +
 +        if (po->flags & OPT_SPEC) {
 +            SpecifierOpt **so = dst;
 +            int i, *count = (int*)(so + 1);
 +            for (i = 0; i < *count; i++) {
 +                av_freep(&(*so)[i].specifier);
 +                if (po->flags & OPT_STRING)
 +                    av_freep(&(*so)[i].u.str);
 +            }
 +            av_freep(so);
 +            *count = 0;
 +        } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 +            av_freep(dst);
 +        po++;
 +    }
 +
 +    for (i = 0; i < o->nb_stream_maps; i++)
 +        av_freep(&o->stream_maps[i].linklabel);
 +    av_freep(&o->stream_maps);
 +    av_freep(&o->audio_channel_maps);
 +    av_freep(&o->streamid_map);
 +
 +    memset(o, 0, sizeof(*o));
 +
 +    if (is_input) {
 +        o->recording_time = bak.recording_time;
 +        if (o->recording_time != INT64_MAX)
 +            av_log(NULL, AV_LOG_WARNING,
 +                   "-t is not an input option, keeping it for the next output;"
 +                   " consider fixing your command line.\n");
 +    } else
 +    o->recording_time = INT64_MAX;
 +    o->mux_max_delay  = 0.7;
 +    o->limit_filesize = UINT64_MAX;
 +    o->chapters_input_file = INT_MAX;
 +
 +    uninit_opts();
 +    init_opts();
 +}
 +
 +
 +static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
 +{
 +    av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
 +    return AVERROR(EINVAL);
 +}
 +
 +static int opt_pad(void *optctx, const char *opt, const char *arg)
 +{
 +    av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
 +    return -1;
 +}
 +
 +static int opt_sameq(void *optctx, const char *opt, const char *arg)
 +{
 +    av_log(NULL, AV_LOG_WARNING, "Ignoring option '%s'\n", opt);
 +    return 0;
 +}
 +
 +static int opt_video_channel(void *optctx, const char *opt, const char *arg)
 +{
 +    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
 +    return opt_default(optctx, "channel", arg);
 +}
 +
 +static int opt_video_standard(void *optctx, const char *opt, const char *arg)
 +{
 +    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
 +    return opt_default(optctx, "standard", arg);
 +}
 +
 +static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "codec:a", arg, options);
 +}
 +
 +static int opt_video_codec(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "codec:v", arg, options);
 +}
 +
 +static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "codec:s", arg, options);
 +}
 +
 +static int opt_data_codec(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "codec:d", arg, options);
 +}
 +
 +static int opt_map(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    StreamMap *m = NULL;
 +    int i, negative = 0, file_idx;
 +    int sync_file_idx = -1, sync_stream_idx = 0;
 +    char *p, *sync;
 +    char *map;
 +
 +    if (*arg == '-') {
 +        negative = 1;
 +        arg++;
 +    }
 +    map = av_strdup(arg);
 +
 +    /* parse sync stream first, just pick first matching stream */
 +    if (sync = strchr(map, ',')) {
 +        *sync = 0;
 +        sync_file_idx = strtol(sync + 1, &sync, 0);
 +        if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
 +            av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
 +            exit(1);
 +        }
 +        if (*sync)
 +            sync++;
 +        for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
 +            if (check_stream_specifier(input_files[sync_file_idx]->ctx,
 +                                       input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
 +                sync_stream_idx = i;
 +                break;
 +            }
 +        if (i == input_files[sync_file_idx]->nb_streams) {
 +            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
 +                                       "match any streams.\n", arg);
 +            exit(1);
 +        }
 +    }
 +
 +
 +    if (map[0] == '[') {
 +        /* this mapping refers to lavfi output */
 +        const char *c = map + 1;
 +        o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
 +                                    &o->nb_stream_maps, o->nb_stream_maps + 1);
 +        m = &o->stream_maps[o->nb_stream_maps - 1];
 +        m->linklabel = av_get_token(&c, "]");
 +        if (!m->linklabel) {
 +            av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
 +            exit(1);
 +        }
 +    } else {
 +        file_idx = strtol(map, &p, 0);
 +        if (file_idx >= nb_input_files || file_idx < 0) {
 +            av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
 +            exit(1);
 +        }
 +        if (negative)
 +            /* disable some already defined maps */
 +            for (i = 0; i < o->nb_stream_maps; i++) {
 +                m = &o->stream_maps[i];
 +                if (file_idx == m->file_index &&
 +                    check_stream_specifier(input_files[m->file_index]->ctx,
 +                                           input_files[m->file_index]->ctx->streams[m->stream_index],
 +                                           *p == ':' ? p + 1 : p) > 0)
 +                    m->disabled = 1;
 +            }
 +        else
 +            for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
 +                if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
 +                            *p == ':' ? p + 1 : p) <= 0)
 +                    continue;
 +                o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
 +                                            &o->nb_stream_maps, o->nb_stream_maps + 1);
 +                m = &o->stream_maps[o->nb_stream_maps - 1];
 +
 +                m->file_index   = file_idx;
 +                m->stream_index = i;
 +
 +                if (sync_file_idx >= 0) {
 +                    m->sync_file_index   = sync_file_idx;
 +                    m->sync_stream_index = sync_stream_idx;
 +                } else {
 +                    m->sync_file_index   = file_idx;
 +                    m->sync_stream_index = i;
 +                }
 +            }
 +    }
 +
 +    if (!m) {
 +        av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
 +        exit(1);
 +    }
 +
 +    av_freep(&map);
 +    return 0;
 +}
 +
 +static int opt_attach(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
 +                                &o->nb_attachments, o->nb_attachments + 1);
 +    o->attachments[o->nb_attachments - 1] = arg;
 +    return 0;
 +}
 +
 +static int opt_map_channel(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    int n;
 +    AVStream *st;
 +    AudioChannelMap *m;
 +
 +    o->audio_channel_maps =
 +        grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
 +                   &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
 +    m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
 +
 +    /* muted channel syntax */
 +    n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
 +    if ((n == 1 || n == 3) && m->channel_idx == -1) {
 +        m->file_idx = m->stream_idx = -1;
 +        if (n == 1)
 +            m->ofile_idx = m->ostream_idx = -1;
 +        return 0;
 +    }
 +
 +    /* normal syntax */
 +    n = sscanf(arg, "%d.%d.%d:%d.%d",
 +               &m->file_idx,  &m->stream_idx, &m->channel_idx,
 +               &m->ofile_idx, &m->ostream_idx);
 +
 +    if (n != 3 && n != 5) {
 +        av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
 +               "[file.stream.channel|-1][:syncfile:syncstream]\n");
 +        exit(1);
 +    }
 +
 +    if (n != 5) // only file.stream.channel specified
 +        m->ofile_idx = m->ostream_idx = -1;
 +
 +    /* check input */
 +    if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
 +        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
 +               m->file_idx);
 +        exit(1);
 +    }
 +    if (m->stream_idx < 0 ||
 +        m->stream_idx >= input_files[m->file_idx]->nb_streams) {
 +        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
 +               m->file_idx, m->stream_idx);
 +        exit(1);
 +    }
 +    st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
 +    if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
 +        av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
 +               m->file_idx, m->stream_idx);
 +        exit(1);
 +    }
 +    if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
 +        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
 +               m->file_idx, m->stream_idx, m->channel_idx);
 +        exit(1);
 +    }
 +    return 0;
 +}
 +
 +/**
 + * Parse a metadata specifier in arg.
 + * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
 + * @param index for type c/p, chapter/program index is written here
 + * @param stream_spec for type s, the stream specifier is written here
 + */
 +static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
 +{
 +    if (*arg) {
 +        *type = *arg;
 +        switch (*arg) {
 +        case 'g':
 +            break;
 +        case 's':
 +            if (*(++arg) && *arg != ':') {
 +                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
 +                exit(1);
 +            }
 +            *stream_spec = *arg == ':' ? arg + 1 : "";
 +            break;
 +        case 'c':
 +        case 'p':
 +            if (*(++arg) == ':')
 +                *index = strtol(++arg, NULL, 0);
 +            break;
 +        default:
 +            av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
 +            exit(1);
 +        }
 +    } else
 +        *type = 'g';
 +}
 +
 +static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
 +{
 +    AVDictionary **meta_in = NULL;
 +    AVDictionary **meta_out = NULL;
 +    int i, ret = 0;
 +    char type_in, type_out;
 +    const char *istream_spec = NULL, *ostream_spec = NULL;
 +    int idx_in = 0, idx_out = 0;
 +
 +    parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
 +    parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
 +
 +    if (!ic) {
 +        if (type_out == 'g' || !*outspec)
 +            o->metadata_global_manual = 1;
 +        if (type_out == 's' || !*outspec)
 +            o->metadata_streams_manual = 1;
 +        if (type_out == 'c' || !*outspec)
 +            o->metadata_chapters_manual = 1;
 +        return 0;
 +    }
 +
 +    if (type_in == 'g' || type_out == 'g')
 +        o->metadata_global_manual = 1;
 +    if (type_in == 's' || type_out == 's')
 +        o->metadata_streams_manual = 1;
 +    if (type_in == 'c' || type_out == 'c')
 +        o->metadata_chapters_manual = 1;
 +
 +#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
 +    if ((index) < 0 || (index) >= (nb_elems)) {\
 +        av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
 +                (desc), (index));\
 +        exit(1);\
 +    }
 +
 +#define SET_DICT(type, meta, context, index)\
 +        switch (type) {\
 +        case 'g':\
 +            meta = &context->metadata;\
 +            break;\
 +        case 'c':\
 +            METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
 +            meta = &context->chapters[index]->metadata;\
 +            break;\
 +        case 'p':\
 +            METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
 +            meta = &context->programs[index]->metadata;\
 +            break;\
 +        default: av_assert0(0);\
 +        case 's':\
 +            break;\
 +        }\
 +
 +    SET_DICT(type_in, meta_in, ic, idx_in);
 +    SET_DICT(type_out, meta_out, oc, idx_out);
 +
 +    /* for input streams choose first matching stream */
 +    if (type_in == 's') {
 +        for (i = 0; i < ic->nb_streams; i++) {
 +            if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
 +                meta_in = &ic->streams[i]->metadata;
 +                break;
 +            } else if (ret < 0)
 +                exit(1);
 +        }
 +        if (!meta_in) {
 +            av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
 +            exit(1);
 +        }
 +    }
 +
 +    if (type_out == 's') {
 +        for (i = 0; i < oc->nb_streams; i++) {
 +            if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
 +                meta_out = &oc->streams[i]->metadata;
 +                av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 +            } else if (ret < 0)
 +                exit(1);
 +        }
 +    } else
 +        av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 +
 +    return 0;
 +}
 +
 +static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    char buf[128];
 +    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
 +    struct tm time = *gmtime((time_t*)&recording_timestamp);
 +    strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
 +    parse_option(o, "metadata", buf, options);
 +
 +    av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
 +                                 "tag instead.\n", opt);
 +    return 0;
 +}
 +
 +static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
 +{
 +    const AVCodecDescriptor *desc;
 +    const char *codec_string = encoder ? "encoder" : "decoder";
 +    AVCodec *codec;
 +
 +    codec = encoder ?
 +        avcodec_find_encoder_by_name(name) :
 +        avcodec_find_decoder_by_name(name);
 +
 +    if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
 +        codec = encoder ? avcodec_find_encoder(desc->id) :
 +                          avcodec_find_decoder(desc->id);
 +        if (codec)
 +            av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
 +                   codec_string, codec->name, desc->name);
 +    }
 +
 +    if (!codec) {
 +        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
 +        exit(1);
 +    }
 +    if (codec->type != type) {
 +        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
 +        exit(1);
 +    }
 +    return codec;
 +}
 +
 +static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
 +{
 +    char *codec_name = NULL;
 +
 +    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
 +    if (codec_name) {
 +        AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
 +        st->codec->codec_id = codec->id;
 +        return codec;
 +    } else
 +        return avcodec_find_decoder(st->codec->codec_id);
 +}
 +
 +/**
 + * Add all the streams from the given input file to the global
 + * list of input streams.
 + */
 +static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
 +{
 +    int i;
 +    char *next, *codec_tag = NULL;
 +
 +    for (i = 0; i < ic->nb_streams; i++) {
 +        AVStream *st = ic->streams[i];
 +        AVCodecContext *dec = st->codec;
 +        InputStream *ist = av_mallocz(sizeof(*ist));
 +        char *framerate = NULL;
 +
 +        if (!ist)
 +            exit(1);
 +
 +        input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
 +        input_streams[nb_input_streams - 1] = ist;
 +
 +        ist->st = st;
 +        ist->file_index = nb_input_files;
 +        ist->discard = 1;
 +        st->discard  = AVDISCARD_ALL;
 +        ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
 +
 +        ist->ts_scale = 1.0;
 +        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
 +
 +        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
 +        if (codec_tag) {
 +            uint32_t tag = strtol(codec_tag, &next, 0);
 +            if (*next)
 +                tag = AV_RL32(codec_tag);
 +            st->codec->codec_tag = tag;
 +        }
 +
 +        ist->dec = choose_decoder(o, ic, st);
 +
 +        switch (dec->codec_type) {
 +        case AVMEDIA_TYPE_VIDEO:
 +            if(!ist->dec)
 +                ist->dec = avcodec_find_decoder(dec->codec_id);
 +            if (dec->lowres) {
 +                dec->flags |= CODEC_FLAG_EMU_EDGE;
 +            }
 +
 +            ist->resample_height  = dec->height;
 +            ist->resample_width   = dec->width;
 +            ist->resample_pix_fmt = dec->pix_fmt;
 +
 +            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
 +            if (framerate && av_parse_video_rate(&ist->framerate,
 +                                                 framerate) < 0) {
 +                av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
 +                       framerate);
 +                exit(1);
 +            }
 +
 +            ist->top_field_first = -1;
 +            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
 +
 +            break;
 +        case AVMEDIA_TYPE_AUDIO:
 +            guess_input_channel_layout(ist);
 +
 +            ist->resample_sample_fmt     = dec->sample_fmt;
 +            ist->resample_sample_rate    = dec->sample_rate;
 +            ist->resample_channels       = dec->channels;
 +            ist->resample_channel_layout = dec->channel_layout;
 +
 +            break;
 +        case AVMEDIA_TYPE_DATA:
 +        case AVMEDIA_TYPE_SUBTITLE:
 +            if(!ist->dec)
 +                ist->dec = avcodec_find_decoder(dec->codec_id);
 +            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
 +            break;
 +        case AVMEDIA_TYPE_ATTACHMENT:
 +        case AVMEDIA_TYPE_UNKNOWN:
 +            break;
 +        default:
 +            abort();
 +        }
 +    }
 +}
 +
 +static void assert_file_overwrite(const char *filename)
 +{
 +    if ((!file_overwrite || no_file_overwrite) &&
 +        (strchr(filename, ':') == NULL || filename[1] == ':' ||
 +         av_strstart(filename, "file:", NULL))) {
 +        if (avio_check(filename, 0) == 0) {
 +            if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
 +                fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
 +                fflush(stderr);
 +                term_exit();
 +                signal(SIGINT, SIG_DFL);
 +                if (!read_yesno()) {
 +                    av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
 +                    exit(1);
 +                }
 +                term_init();
 +            }
 +            else {
 +                av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
 +                exit(1);
 +            }
 +        }
 +    }
 +}
 +
 +static void dump_attachment(AVStream *st, const char *filename)
 +{
 +    int ret;
 +    AVIOContext *out = NULL;
 +    AVDictionaryEntry *e;
 +
 +    if (!st->codec->extradata_size) {
 +        av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
 +               nb_input_files - 1, st->index);
 +        return;
 +    }
 +    if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
 +        filename = e->value;
 +    if (!*filename) {
 +        av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
 +               "in stream #%d:%d.\n", nb_input_files - 1, st->index);
 +        exit(1);
 +    }
 +
 +    assert_file_overwrite(filename);
 +
 +    if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
 +        av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
 +               filename);
 +        exit(1);
 +    }
 +
 +    avio_write(out, st->codec->extradata, st->codec->extradata_size);
 +    avio_flush(out);
 +    avio_close(out);
 +}
 +
 +static int opt_input_file(void *optctx, const char *opt, const char *filename)
 +{
 +    OptionsContext *o = optctx;
 +    AVFormatContext *ic;
 +    AVInputFormat *file_iformat = NULL;
 +    int err, i, ret;
 +    int64_t timestamp;
 +    uint8_t buf[128];
 +    AVDictionary **opts;
 +    int orig_nb_streams;                     // number of streams before avformat_find_stream_info
 +    char *   video_codec_name = NULL;
 +    char *   audio_codec_name = NULL;
 +    char *subtitle_codec_name = NULL;
 +
 +    if (o->format) {
 +        if (!(file_iformat = av_find_input_format(o->format))) {
 +            av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
 +            exit(1);
 +        }
 +    }
 +
 +    if (!strcmp(filename, "-"))
 +        filename = "pipe:";
 +
 +    stdin_interaction &= strncmp(filename, "pipe:", 5) &&
 +                         strcmp(filename, "/dev/stdin");
 +
 +    /* get default parameters from command line */
 +    ic = avformat_alloc_context();
 +    if (!ic) {
 +        print_error(filename, AVERROR(ENOMEM));
 +        exit(1);
 +    }
 +    if (o->nb_audio_sample_rate) {
 +        snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
 +        av_dict_set(&format_opts, "sample_rate", buf, 0);
 +    }
 +    if (o->nb_audio_channels) {
 +        /* because we set audio_channels based on both the "ac" and
 +         * "channel_layout" options, we need to check that the specified
 +         * demuxer actually has the "channels" option before setting it */
 +        if (file_iformat && file_iformat->priv_class &&
 +            av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
 +                        AV_OPT_SEARCH_FAKE_OBJ)) {
 +            snprintf(buf, sizeof(buf), "%d",
 +                     o->audio_channels[o->nb_audio_channels - 1].u.i);
 +            av_dict_set(&format_opts, "channels", buf, 0);
 +        }
 +    }
 +    if (o->nb_frame_rates) {
 +        /* set the format-level framerate option;
 +         * this is important for video grabbers, e.g. x11 */
 +        if (file_iformat && file_iformat->priv_class &&
 +            av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
 +                        AV_OPT_SEARCH_FAKE_OBJ)) {
 +            av_dict_set(&format_opts, "framerate",
 +                        o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
 +        }
 +    }
 +    if (o->nb_frame_sizes) {
 +        av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
 +    }
 +    if (o->nb_frame_pix_fmts)
 +        av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
 +
 +    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
 +    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
 +    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
 +
 +    ic->video_codec_id   = video_codec_name ?
 +        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
 +    ic->audio_codec_id   = audio_codec_name ?
 +        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
 +    ic->subtitle_codec_id= subtitle_codec_name ?
 +        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
 +    ic->flags |= AVFMT_FLAG_NONBLOCK;
 +    ic->interrupt_callback = int_cb;
 +
 +    /* open the input file with generic avformat function */
 +    err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
 +    if (err < 0) {
 +        print_error(filename, err);
 +        exit(1);
 +    }
 +    assert_avoptions(format_opts);
 +
 +    /* apply forced codec ids */
 +    for (i = 0; i < ic->nb_streams; i++)
 +        choose_decoder(o, ic, ic->streams[i]);
 +
 +    /* Set AVCodecContext options for avformat_find_stream_info */
 +    opts = setup_find_stream_info_opts(ic, codec_opts);
 +    orig_nb_streams = ic->nb_streams;
 +
 +    /* If not enough info to get the stream parameters, we decode the
 +       first frames to get it. (used in mpeg case for example) */
 +    ret = avformat_find_stream_info(ic, opts);
 +    if (ret < 0) {
 +        av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
 +        avformat_close_input(&ic);
 +        exit(1);
 +    }
 +
 +    timestamp = o->start_time;
 +    /* add the stream start time */
 +    if (ic->start_time != AV_NOPTS_VALUE)
 +        timestamp += ic->start_time;
 +
 +    /* if seeking requested, we execute it */
 +    if (o->start_time != 0) {
 +        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
 +        if (ret < 0) {
 +            av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
 +                   filename, (double)timestamp / AV_TIME_BASE);
 +        }
 +    }
 +
 +    /* update the current parameters so that they match the one of the input stream */
 +    add_input_streams(o, ic);
 +
 +    /* dump the file content */
 +    av_dump_format(ic, nb_input_files, filename, 0);
 +
 +    input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
 +    if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
 +        exit(1);
 +
 +    input_files[nb_input_files - 1]->ctx        = ic;
 +    input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
 +    input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
 +    input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
 +    input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
 +
 +    for (i = 0; i < o->nb_dump_attachment; i++) {
 +        int j;
 +
 +        for (j = 0; j < ic->nb_streams; j++) {
 +            AVStream *st = ic->streams[j];
 +
 +            if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
 +                dump_attachment(st, o->dump_attachment[i].u.str);
 +        }
 +    }
 +
 +    for (i = 0; i < orig_nb_streams; i++)
 +        av_dict_free(&opts[i]);
 +    av_freep(&opts);
 +
 +    reset_options(o, 1);
 +    return 0;
 +}
 +
 +static uint8_t *get_line(AVIOContext *s)
 +{
 +    AVIOContext *line;
 +    uint8_t *buf;
 +    char c;
 +
 +    if (avio_open_dyn_buf(&line) < 0) {
 +        av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
 +        exit(1);
 +    }
 +
 +    while ((c = avio_r8(s)) && c != '\n')
 +        avio_w8(line, c);
 +    avio_w8(line, 0);
 +    avio_close_dyn_buf(line, &buf);
 +
 +    return buf;
 +}
 +
 +static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
 +{
 +    int i, ret = 1;
 +    char filename[1000];
 +    const char *base[3] = { getenv("AVCONV_DATADIR"),
 +                            getenv("HOME"),
 +                            AVCONV_DATADIR,
 +                            };
 +
 +    for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
 +        if (!base[i])
 +            continue;
 +        if (codec_name) {
 +            snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
 +                     i != 1 ? "" : "/.avconv", codec_name, preset_name);
 +            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 +        }
 +        if (ret) {
 +            snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
 +                     i != 1 ? "" : "/.avconv", preset_name);
 +            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 +        }
 +    }
 +    return ret;
 +}
 +
 +static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
 +{
 +    char *codec_name = NULL;
 +
 +    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
 +    if (!codec_name) {
 +        ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 +                                                  NULL, ost->st->codec->codec_type);
 +        ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
 +    } else if (!strcmp(codec_name, "copy"))
 +        ost->stream_copy = 1;
 +    else {
 +        ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
 +        ost->st->codec->codec_id = ost->enc->id;
 +    }
 +}
 +
 +static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
 +{
 +    OutputStream *ost;
 +    AVStream *st = avformat_new_stream(oc, NULL);
 +    int idx      = oc->nb_streams - 1, ret = 0;
 +    char *bsf = NULL, *next, *codec_tag = NULL;
 +    AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
 +    double qscale = -1;
 +    char *buf = NULL, *arg = NULL, *preset = NULL;
 +    AVIOContext *s = NULL;
 +
 +    if (!st) {
 +        av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 +        exit(1);
 +    }
 +
 +    if (oc->nb_streams - 1 < o->nb_streamid_map)
 +        st->id = o->streamid_map[oc->nb_streams - 1];
 +
 +    output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
 +                                nb_output_streams + 1);
 +    if (!(ost = av_mallocz(sizeof(*ost))))
 +        exit(1);
 +    output_streams[nb_output_streams - 1] = ost;
 +
 +    ost->file_index = nb_output_files;
 +    ost->index      = idx;
 +    ost->st         = st;
 +    st->codec->codec_type = type;
 +    choose_encoder(o, oc, ost);
 +    if (ost->enc) {
 +        ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
 +    }
 +
 +    avcodec_get_context_defaults3(st->codec, ost->enc);
 +    st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
 +
 +    MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 +    if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 +        do  {
 +            buf = get_line(s);
 +            if (!buf[0] || buf[0] == '#') {
 +                av_free(buf);
 +                continue;
 +            }
 +            if (!(arg = strchr(buf, '='))) {
 +                av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
 +                exit(1);
 +            }
 +            *arg++ = 0;
 +            av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
 +            av_free(buf);
 +        } while (!s->eof_reached);
 +        avio_close(s);
 +    }
 +    if (ret) {
 +        av_log(NULL, AV_LOG_FATAL,
 +               "Preset %s specified for stream %d:%d, but could not be opened.\n",
 +               preset, ost->file_index, ost->index);
 +        exit(1);
 +    }
 +
 +    ost->max_frames = INT64_MAX;
 +    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 +
 +    ost->copy_prior_start = -1;
 +    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
 +
 +    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 +    while (bsf) {
 +        if (next = strchr(bsf, ','))
 +            *next++ = 0;
 +        if (!(bsfc = av_bitstream_filter_init(bsf))) {
 +            av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 +            exit(1);
 +        }
 +        if (bsfc_prev)
 +            bsfc_prev->next = bsfc;
 +        else
 +            ost->bitstream_filters = bsfc;
 +
 +        bsfc_prev = bsfc;
 +        bsf       = next;
 +    }
 +
 +    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
 +    if (codec_tag) {
 +        uint32_t tag = strtol(codec_tag, &next, 0);
 +        if (*next)
 +            tag = AV_RL32(codec_tag);
 +        st->codec->codec_tag = tag;
 +    }
 +
 +    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
 +    if (qscale >= 0) {
 +        st->codec->flags |= CODEC_FLAG_QSCALE;
 +        st->codec->global_quality = FF_QP2LAMBDA * qscale;
 +    }
 +
 +    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 +        st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
 +
 +    av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
 +    av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
 +    av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
 +
 +    ost->source_index = source_index;
 +    if (source_index >= 0) {
 +        ost->sync_ist = input_streams[source_index];
 +        input_streams[source_index]->discard = 0;
 +        input_streams[source_index]->st->discard = AVDISCARD_NONE;
 +    }
 +
 +    return ost;
 +}
 +
 +static void parse_matrix_coeffs(uint16_t *dest, const char *str)
 +{
 +    int i;
 +    const char *p = str;
 +    for (i = 0;; i++) {
 +        dest[i] = atoi(p);
 +        if (i == 63)
 +            break;
 +        p = strchr(p, ',');
 +        if (!p) {
 +            av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
 +            exit(1);
 +        }
 +        p++;
 +    }
 +}
 +
 +static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
 +{
 +    AVStream *st;
 +    OutputStream *ost;
 +    AVCodecContext *video_enc;
 +    char *frame_rate = NULL;
 +
 +    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
 +    st  = ost->st;
 +    video_enc = st->codec;
 +
 +    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
 +    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
 +        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
 +        exit(1);
 +    }
 +
 +    if (!ost->stream_copy) {
 +        const char *p = NULL;
 +        char *frame_size = NULL;
 +        char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
 +        char *intra_matrix = NULL, *inter_matrix = NULL;
 +        const char *filters = "null";
 +        int do_pass = 0;
 +        int i;
 +
 +        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
 +        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
 +            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
 +            exit(1);
 +        }
 +
 +        MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
 +        if (frame_aspect_ratio) {
 +            AVRational q;
 +            if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
 +                q.num <= 0 || q.den <= 0) {
 +                av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
 +                exit(1);
 +            }
 +            ost->frame_aspect_ratio = av_q2d(q);
 +        }
 +
 +        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
 +        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
 +        if (frame_pix_fmt && *frame_pix_fmt == '+') {
 +            ost->keep_pix_fmt = 1;
 +            if (!*++frame_pix_fmt)
 +                frame_pix_fmt = NULL;
 +        }
 +        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
 +            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
 +            exit(1);
 +        }
 +        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
 +
 +        if (intra_only)
 +            video_enc->gop_size = 0;
 +        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
 +        if (intra_matrix) {
 +            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
 +                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
 +                exit(1);
 +            }
 +            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
 +        }
 +        MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
 +        if (inter_matrix) {
 +            if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
 +                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
 +                exit(1);
 +            }
 +            parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
 +        }
 +
 +        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
 +        for (i = 0; p; i++) {
 +            int start, end, q;
 +            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
 +            if (e != 3) {
 +                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
 +                exit(1);
 +            }
 +            /* FIXME realloc failure */
 +            video_enc->rc_override =
 +                av_realloc(video_enc->rc_override,
 +                           sizeof(RcOverride) * (i + 1));
 +            video_enc->rc_override[i].start_frame = start;
 +            video_enc->rc_override[i].end_frame   = end;
 +            if (q > 0) {
 +                video_enc->rc_override[i].qscale         = q;
 +                video_enc->rc_override[i].quality_factor = 1.0;
 +            }
 +            else {
 +                video_enc->rc_override[i].qscale         = 0;
 +                video_enc->rc_override[i].quality_factor = -q/100.0;
 +            }
 +            p = strchr(p, '/');
 +            if (p) p++;
 +        }
 +        video_enc->rc_override_count = i;
 +        if (!video_enc->rc_initial_buffer_occupancy)
 +            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
 +        video_enc->intra_dc_precision = intra_dc_precision - 8;
 +
 +        if (do_psnr)
 +            video_enc->flags|= CODEC_FLAG_PSNR;
 +
 +        /* two pass mode */
 +        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
 +        if (do_pass) {
 +            if (do_pass & 1) {
 +                video_enc->flags |= CODEC_FLAG_PASS1;
 +            }
 +            if (do_pass & 2) {
 +                video_enc->flags |= CODEC_FLAG_PASS2;
 +            }
 +        }
 +
 +        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
 +        if (ost->logfile_prefix &&
 +            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
 +            exit(1);
 +
 +        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
 +        if (ost->forced_keyframes)
 +            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
 +
 +        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
 +
 +        ost->top_field_first = -1;
 +        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
 +
 +        MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
 +        ost->avfilter = av_strdup(filters);
 +    } else {
 +        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
 +    }
 +
 +    return ost;
 +}
 +
 +static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
 +{
 +    int n;
 +    AVStream *st;
 +    OutputStream *ost;
 +    AVCodecContext *audio_enc;
 +
 +    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
 +    st  = ost->st;
 +
 +    audio_enc = st->codec;
 +    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
 +
 +    if (!ost->stream_copy) {
 +        char *sample_fmt = NULL;
 +        const char *filters = "anull";
 +
 +        MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
 +
 +        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
 +        if (sample_fmt &&
 +            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
 +            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
 +            exit(1);
 +        }
 +
 +        MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
 +
 +        MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
 +
 +        av_assert1(filters);
 +        ost->avfilter = av_strdup(filters);
 +
 +        /* check for channel mapping for this audio stream */
 +        for (n = 0; n < o->nb_audio_channel_maps; n++) {
 +            AudioChannelMap *map = &o->audio_channel_maps[n];
 +            InputStream *ist = input_streams[ost->source_index];
 +            if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
 +                (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
 +                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
 +                if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
 +                    ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
 +                else
 +                    av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
 +                           ost->file_index, ost->st->index);
 +            }
 +        }
 +    }
 +
 +    return ost;
 +}
 +
 +static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
 +{
 +    OutputStream *ost;
 +
 +    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
 +    if (!ost->stream_copy) {
 +        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
 +        exit(1);
 +    }
 +
 +    return ost;
 +}
 +
 +static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
 +{
 +    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
 +    ost->stream_copy = 1;
 +    return ost;
 +}
 +
 +static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
 +{
 +    AVStream *st;
 +    OutputStream *ost;
 +    AVCodecContext *subtitle_enc;
 +
 +    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
 +    st  = ost->st;
 +    subtitle_enc = st->codec;
 +
 +    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
 +
 +    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
 +
 +    if (!ost->stream_copy) {
 +        char *frame_size = NULL;
 +
 +        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
 +        if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
 +            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
 +            exit(1);
 +        }
 +    }
 +
 +    return ost;
 +}
 +
 +/* arg format is "output-stream-index:streamid-value". */
 +static int opt_streamid(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    int idx;
 +    char *p;
 +    char idx_str[16];
 +
 +    av_strlcpy(idx_str, arg, sizeof(idx_str));
 +    p = strchr(idx_str, ':');
 +    if (!p) {
 +        av_log(NULL, AV_LOG_FATAL,
 +               "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
 +               arg, opt);
 +        exit(1);
 +    }
 +    *p++ = '\0';
 +    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
 +    o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
 +    o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
 +    return 0;
 +}
 +
 +static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
 +{
 +    AVFormatContext *is = ifile->ctx;
 +    AVFormatContext *os = ofile->ctx;
 +    AVChapter **tmp;
 +    int i;
 +
 +    tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
 +    if (!tmp)
 +        return AVERROR(ENOMEM);
 +    os->chapters = tmp;
 +
 +    for (i = 0; i < is->nb_chapters; i++) {
 +        AVChapter *in_ch = is->chapters[i], *out_ch;
 +        int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
 +                                       AV_TIME_BASE_Q, in_ch->time_base);
 +        int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
 +                           av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
 +
 +
 +        if (in_ch->end < ts_off)
 +            continue;
 +        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
 +            break;
 +
 +        out_ch = av_mallocz(sizeof(AVChapter));
 +        if (!out_ch)
 +            return AVERROR(ENOMEM);
 +
 +        out_ch->id        = in_ch->id;
 +        out_ch->time_base = in_ch->time_base;
 +        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
 +        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
 +
 +        if (copy_metadata)
 +            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
 +
 +        os->chapters[os->nb_chapters++] = out_ch;
 +    }
 +    return 0;
 +}
 +
 +static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
 +{
 +    int i, err;
 +    AVFormatContext *ic = avformat_alloc_context();
 +
 +    ic->interrupt_callback = int_cb;
 +    err = avformat_open_input(&ic, filename, NULL, NULL);
 +    if (err < 0)
 +        return err;
 +    /* copy stream format */
 +    for(i=0;i<ic->nb_streams;i++) {
 +        AVStream *st;
 +        OutputStream *ost;
 +        AVCodec *codec;
 +        AVCodecContext *avctx;
 +
 +        codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
 +        ost   = new_output_stream(o, s, codec->type, -1);
 +        st    = ost->st;
 +        avctx = st->codec;
 +        ost->enc = codec;
 +
 +        // FIXME: a more elegant solution is needed
 +        memcpy(st, ic->streams[i], sizeof(AVStream));
 +        st->cur_dts = 0;
 +        st->info = av_malloc(sizeof(*st->info));
 +        memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
 +        st->codec= avctx;
 +        avcodec_copy_context(st->codec, ic->streams[i]->codec);
 +
 +        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
 +            choose_sample_fmt(st, codec);
 +        else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
 +            choose_pixel_fmt(st, codec, st->codec->pix_fmt);
 +    }
 +
 +    /* ffserver seeking with date=... needs a date reference */
 +    err = parse_option(o, "metadata", "creation_time=now", options);
 +
 +    avformat_close_input(&ic);
 +    return err;
 +}
 +
 +static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
 +                               AVFormatContext *oc)
 +{
 +    OutputStream *ost;
 +
 +    switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
 +                                  ofilter->out_tmp->pad_idx)) {
 +    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
 +    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
 +    default:
 +        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
 +               "currently.\n");
 +        exit(1);
 +    }
 +
 +    ost->source_index = -1;
 +    ost->filter       = ofilter;
 +
 +    ofilter->ost      = ost;
 +
 +    if (ost->stream_copy) {
 +        av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
 +               "which is fed from a complex filtergraph. Filtering and streamcopy "
 +               "cannot be used together.\n", ost->file_index, ost->index);
 +        exit(1);
 +    }
 +
 +    if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
 +        av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
 +        exit(1);
 +    }
 +    avfilter_inout_free(&ofilter->out_tmp);
 +}
 +
 +static int configure_complex_filters(void)
 +{
 +    int i, ret = 0;
 +
 +    for (i = 0; i < nb_filtergraphs; i++)
 +        if (!filtergraphs[i]->graph &&
 +            (ret = configure_filtergraph(filtergraphs[i])) < 0)
 +            return ret;
 +    return 0;
 +}
 +
 +void opt_output_file(void *optctx, const char *filename)
 +{
 +    OptionsContext *o = optctx;
 +    AVFormatContext *oc;
 +    int i, j, err;
 +    AVOutputFormat *file_oformat;
 +    OutputStream *ost;
 +    InputStream  *ist;
 +
 +    if (configure_complex_filters() < 0) {
 +        av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
 +        exit(1);
 +    }
 +
 +    if (!strcmp(filename, "-"))
 +        filename = "pipe:";
 +
 +    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
 +    if (!oc) {
 +        print_error(filename, err);
 +        exit(1);
 +    }
 +    file_oformat= oc->oformat;
 +    oc->interrupt_callback = int_cb;
 +
 +    /* create streams for all unlabeled output pads */
 +    for (i = 0; i < nb_filtergraphs; i++) {
 +        FilterGraph *fg = filtergraphs[i];
 +        for (j = 0; j < fg->nb_outputs; j++) {
 +            OutputFilter *ofilter = fg->outputs[j];
 +
 +            if (!ofilter->out_tmp || ofilter->out_tmp->name)
 +                continue;
 +
 +            switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
 +                                          ofilter->out_tmp->pad_idx)) {
 +            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
 +            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
 +            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
 +            }
 +            init_output_filter(ofilter, o, oc);
 +        }
 +    }
 +
 +    if (!strcmp(file_oformat->name, "ffm") &&
 +        av_strstart(filename, "http:", NULL)) {
 +        int j;
 +        /* special case for files sent to ffserver: we get the stream
 +           parameters from ffserver */
 +        int err = read_ffserver_streams(o, oc, filename);
 +        if (err < 0) {
 +            print_error(filename, err);
 +            exit(1);
 +        }
 +        for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
 +            ost = output_streams[j];
 +            for (i = 0; i < nb_input_streams; i++) {
 +                ist = input_streams[i];
 +                if(ist->st->codec->codec_type == ost->st->codec->codec_type){
 +                    ost->sync_ist= ist;
 +                    ost->source_index= i;
 +                    if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
 +                    if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
 +                    ist->discard = 0;
 +                    ist->st->discard = AVDISCARD_NONE;
 +                    break;
 +                }
 +            }
 +            if(!ost->sync_ist){
 +                av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
 +                exit(1);
 +            }
 +        }
 +    } else if (!o->nb_stream_maps) {
 +        char *subtitle_codec_name = NULL;
 +        /* pick the "best" stream of each type */
 +
 +        /* video: highest resolution */
 +        if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
 +            int area = 0, idx = -1;
 +            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
 +            for (i = 0; i < nb_input_streams; i++) {
 +                int new_area;
 +                ist = input_streams[i];
 +                new_area = ist->st->codec->width * ist->st->codec->height;
 +                if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
 +                    new_area = 1;
 +                if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
 +                    new_area > area) {
 +                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
 +                        continue;
 +                    area = new_area;
 +                    idx = i;
 +                }
 +            }
 +            if (idx >= 0)
 +                new_video_stream(o, oc, idx);
 +        }
 +
 +        /* audio: most channels */
 +        if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
 +            int channels = 0, idx = -1;
 +            for (i = 0; i < nb_input_streams; i++) {
 +                ist = input_streams[i];
 +                if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
 +                    ist->st->codec->channels > channels) {
 +                    channels = ist->st->codec->channels;
 +                    idx = i;
 +                }
 +            }
 +            if (idx >= 0)
 +                new_audio_stream(o, oc, idx);
 +        }
 +
 +        /* subtitles: pick first */
 +        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
 +        if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
 +            for (i = 0; i < nb_input_streams; i++)
 +                if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 +                    new_subtitle_stream(o, oc, i);
 +                    break;
 +                }
 +        }
 +        /* do something with data? */
 +    } else {
 +        for (i = 0; i < o->nb_stream_maps; i++) {
 +            StreamMap *map = &o->stream_maps[i];
 +            int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
 +
 +            if (map->disabled)
 +                continue;
 +
 +            if (map->linklabel) {
 +                FilterGraph *fg;
 +                OutputFilter *ofilter = NULL;
 +                int j, k;
 +
 +                for (j = 0; j < nb_filtergraphs; j++) {
 +                    fg = filtergraphs[j];
 +                    for (k = 0; k < fg->nb_outputs; k++) {
 +                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
 +                        if (out && !strcmp(out->name, map->linklabel)) {
 +                            ofilter = fg->outputs[k];
 +                            goto loop_end;
 +                        }
 +                    }
 +                }
 +loop_end:
 +                if (!ofilter) {
 +                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
 +                           "in any defined filter graph.\n", map->linklabel);
 +                    exit(1);
 +                }
 +                init_output_filter(ofilter, o, oc);
 +            } else {
 +                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
 +                if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
 +                    continue;
 +                if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
 +                    continue;
 +                if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 +                    continue;
 +                if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
 +                    continue;
 +
 +                switch (ist->st->codec->codec_type) {
 +                case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
 +                case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
 +                case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
 +                case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
 +                case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
 +                default:
 +                    av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
 +                           map->file_index, map->stream_index);
 +                    exit(1);
 +                }
 +            }
 +        }
 +    }
 +
 +
 +    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
 +        AVDictionaryEntry *e;
 +        ost = output_streams[i];
 +
 +        if (   ost->stream_copy
 +            && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
 +            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
 +            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
 +                exit(1);
 +    }
 +
 +    /* handle attached files */
 +    for (i = 0; i < o->nb_attachments; i++) {
 +        AVIOContext *pb;
 +        uint8_t *attachment;
 +        const char *p;
 +        int64_t len;
 +
 +        if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
 +            av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
 +                   o->attachments[i]);
 +            exit(1);
 +        }
 +        if ((len = avio_size(pb)) <= 0) {
 +            av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
 +                   o->attachments[i]);
 +            exit(1);
 +        }
 +        if (!(attachment = av_malloc(len))) {
 +            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
 +                   o->attachments[i]);
 +            exit(1);
 +        }
 +        avio_read(pb, attachment, len);
 +
 +        ost = new_attachment_stream(o, oc, -1);
 +        ost->stream_copy               = 0;
 +        ost->attachment_filename       = o->attachments[i];
 +        ost->st->codec->extradata      = attachment;
 +        ost->st->codec->extradata_size = len;
 +
 +        p = strrchr(o->attachments[i], '/');
 +        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
 +        avio_close(pb);
 +    }
 +
 +    output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
 +    if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
 +        exit(1);
 +
 +    output_files[nb_output_files - 1]->ctx            = oc;
 +    output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
 +    output_files[nb_output_files - 1]->recording_time = o->recording_time;
 +    if (o->recording_time != INT64_MAX)
 +        oc->duration = o->recording_time;
 +    output_files[nb_output_files - 1]->start_time     = o->start_time;
 +    output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
 +    output_files[nb_output_files - 1]->shortest       = o->shortest;
 +    av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
 +
 +    /* check filename in case of an image number is expected */
 +    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
 +        if (!av_filename_number_test(oc->filename)) {
 +            print_error(oc->filename, AVERROR(EINVAL));
 +            exit(1);
 +        }
 +    }
 +
 +    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
 +        /* test if it already exists to avoid losing precious files */
 +        assert_file_overwrite(filename);
 +
 +        /* open the file */
 +        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
 +                              &oc->interrupt_callback,
 +                              &output_files[nb_output_files - 1]->opts)) < 0) {
 +            print_error(filename, err);
 +            exit(1);
 +        }
 +    }
 +
 +    if (o->mux_preload) {
 +        uint8_t buf[64];
 +        snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
 +        av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
 +    }
 +    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
 +
 +    /* copy metadata */
 +    for (i = 0; i < o->nb_metadata_map; i++) {
 +        char *p;
 +        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
 +
 +        if (in_file_index >= nb_input_files) {
 +            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
 +            exit(1);
 +        }
 +        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
 +    }
 +
 +    /* copy chapters */
 +    if (o->chapters_input_file >= nb_input_files) {
 +        if (o->chapters_input_file == INT_MAX) {
 +            /* copy chapters from the first input file that has them*/
 +            o->chapters_input_file = -1;
 +            for (i = 0; i < nb_input_files; i++)
 +                if (input_files[i]->ctx->nb_chapters) {
 +                    o->chapters_input_file = i;
 +                    break;
 +                }
 +        } else {
 +            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
 +                   o->chapters_input_file);
 +            exit(1);
 +        }
 +    }
 +    if (o->chapters_input_file >= 0)
 +        copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
 +                      !o->metadata_chapters_manual);
 +
 +    /* copy global metadata by default */
 +    if (!o->metadata_global_manual && nb_input_files){
 +        av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
 +                     AV_DICT_DONT_OVERWRITE);
 +        if(o->recording_time != INT64_MAX)
 +            av_dict_set(&oc->metadata, "duration", NULL, 0);
 +        av_dict_set(&oc->metadata, "creation_time", NULL, 0);
 +    }
 +    if (!o->metadata_streams_manual)
 +        for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
 +            InputStream *ist;
 +            if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
 +                continue;
 +            ist = input_streams[output_streams[i]->source_index];
 +            av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
 +        }
 +
 +    /* process manually set metadata */
 +    for (i = 0; i < o->nb_metadata; i++) {
 +        AVDictionary **m;
 +        char type, *val;
 +        const char *stream_spec;
 +        int index = 0, j, ret = 0;
 +
 +        val = strchr(o->metadata[i].u.str, '=');
 +        if (!val) {
 +            av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
 +                   o->metadata[i].u.str);
 +            exit(1);
 +        }
 +        *val++ = 0;
 +
 +        parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
 +        if (type == 's') {
 +            for (j = 0; j < oc->nb_streams; j++) {
 +                if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
 +                    av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
 +                } else if (ret < 0)
 +                    exit(1);
 +            }
 +        }
 +        else {
 +            switch (type) {
 +            case 'g':
 +                m = &oc->metadata;
 +                break;
 +            case 'c':
 +                if (index < 0 || index >= oc->nb_chapters) {
 +                    av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
 +                    exit(1);
 +                }
 +                m = &oc->chapters[index]->metadata;
 +                break;
 +            default:
 +                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
 +                exit(1);
 +            }
 +            av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
 +        }
 +    }
 +
 +    reset_options(o, 0);
 +}
 +
 +static int opt_target(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
 +    static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
 +
 +    if (!strncmp(arg, "pal-", 4)) {
 +        norm = PAL;
 +        arg += 4;
 +    } else if (!strncmp(arg, "ntsc-", 5)) {
 +        norm = NTSC;
 +        arg += 5;
 +    } else if (!strncmp(arg, "film-", 5)) {
 +        norm = FILM;
 +        arg += 5;
 +    } else {
 +        /* Try to determine PAL/NTSC by peeking in the input files */
 +        if (nb_input_files) {
 +            int i, j, fr;
 +            for (j = 0; j < nb_input_files; j++) {
 +                for (i = 0; i < input_files[j]->nb_streams; i++) {
 +                    AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
 +                    if (c->codec_type != AVMEDIA_TYPE_VIDEO)
 +                        continue;
 +                    fr = c->time_base.den * 1000 / c->time_base.num;
 +                    if (fr == 25000) {
 +                        norm = PAL;
 +                        break;
 +                    } else if ((fr == 29970) || (fr == 23976)) {
 +                        norm = NTSC;
 +                        break;
 +                    }
 +                }
 +                if (norm != UNKNOWN)
 +                    break;
 +            }
 +        }
 +        if (norm != UNKNOWN)
 +            av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
 +    }
 +
 +    if (norm == UNKNOWN) {
 +        av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
 +        av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
 +        av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
 +        exit(1);
 +    }
 +
 +    if (!strcmp(arg, "vcd")) {
 +        opt_video_codec(o, "c:v", "mpeg1video");
 +        opt_audio_codec(o, "c:a", "mp2");
 +        parse_option(o, "f", "vcd", options);
 +
 +        parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
 +        parse_option(o, "r", frame_rates[norm], options);
 +        opt_default(NULL, "g", norm == PAL ? "15" : "18");
 +
 +        opt_default(NULL, "b:v", "1150000");
 +        opt_default(NULL, "maxrate", "1150000");
 +        opt_default(NULL, "minrate", "1150000");
 +        opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
 +
 +        opt_default(NULL, "b:a", "224000");
 +        parse_option(o, "ar", "44100", options);
 +        parse_option(o, "ac", "2", options);
 +
 +        opt_default(NULL, "packetsize", "2324");
 +        opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
 +
 +        /* We have to offset the PTS, so that it is consistent with the SCR.
 +           SCR starts at 36000, but the first two packs contain only padding
 +           and the first pack from the other stream, respectively, may also have
 +           been written before.
 +           So the real data starts at SCR 36000+3*1200. */
 +        o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
 +    } else if (!strcmp(arg, "svcd")) {
 +
 +        opt_video_codec(o, "c:v", "mpeg2video");
 +        opt_audio_codec(o, "c:a", "mp2");
 +        parse_option(o, "f", "svcd", options);
 +
 +        parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
 +        parse_option(o, "r", frame_rates[norm], options);
 +        parse_option(o, "pix_fmt", "yuv420p", options);
 +        opt_default(NULL, "g", norm == PAL ? "15" : "18");
 +
 +        opt_default(NULL, "b:v", "2040000");
 +        opt_default(NULL, "maxrate", "2516000");
 +        opt_default(NULL, "minrate", "0"); // 1145000;
 +        opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
 +        opt_default(NULL, "scan_offset", "1");
 +
 +        opt_default(NULL, "b:a", "224000");
 +        parse_option(o, "ar", "44100", options);
 +
 +        opt_default(NULL, "packetsize", "2324");
 +
 +    } else if (!strcmp(arg, "dvd")) {
 +
 +        opt_video_codec(o, "c:v", "mpeg2video");
 +        opt_audio_codec(o, "c:a", "ac3");
 +        parse_option(o, "f", "dvd", options);
 +
 +        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
 +        parse_option(o, "r", frame_rates[norm], options);
 +        parse_option(o, "pix_fmt", "yuv420p", options);
 +        opt_default(NULL, "g", norm == PAL ? "15" : "18");
 +
 +        opt_default(NULL, "b:v", "6000000");
 +        opt_default(NULL, "maxrate", "9000000");
 +        opt_default(NULL, "minrate", "0"); // 1500000;
 +        opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
 +
 +        opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
 +        opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
 +
 +        opt_default(NULL, "b:a", "448000");
 +        parse_option(o, "ar", "48000", options);
 +
 +    } else if (!strncmp(arg, "dv", 2)) {
 +
 +        parse_option(o, "f", "dv", options);
 +
 +        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
 +        parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
 +                          norm == PAL ? "yuv420p" : "yuv411p", options);
 +        parse_option(o, "r", frame_rates[norm], options);
 +
 +        parse_option(o, "ar", "48000", options);
 +        parse_option(o, "ac", "2", options);
 +
 +    } else {
 +        av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
 +        return AVERROR(EINVAL);
 +    }
 +    return 0;
 +}
 +
 +static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
 +{
 +    av_free (vstats_filename);
 +    vstats_filename = av_strdup (arg);
 +    return 0;
 +}
 +
 +static int opt_vstats(void *optctx, const char *opt, const char *arg)
 +{
 +    char filename[40];
 +    time_t today2 = time(NULL);
 +    struct tm *today = localtime(&today2);
 +
 +    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
 +             today->tm_sec);
 +    return opt_vstats_file(NULL, opt, filename);
 +}
 +
 +static int opt_video_frames(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "frames:v", arg, options);
 +}
 +
 +static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "frames:a", arg, options);
 +}
 +
 +static int opt_data_frames(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "frames:d", arg, options);
 +}
 +
 +static int opt_preset(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    FILE *f=NULL;
 +    char filename[1000], line[1000], tmp_line[1000];
 +    const char *codec_name = NULL;
 +
 +    tmp_line[0] = *opt;
 +    tmp_line[1] = 0;
 +    MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
 +
 +    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
 +        if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
 +            av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
 +        }else
 +            av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
 +        exit(1);
 +}
 +
 +    while (fgets(line, sizeof(line), f)) {
 +        char *key = tmp_line, *value, *endptr;
 +
 +        if (strcspn(line, "#\n\r") == 0)
 +            continue;
 +        strcpy(tmp_line, line);
 +        if (!av_strtok(key,   "=",    &value) ||
 +            !av_strtok(value, "\r\n", &endptr)) {
 +            av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
 +            exit(1);
 +        }
 +        av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
 +
 +        if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
 +        else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
 +        else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
 +        else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
 +        else if (opt_default(NULL, key, value) < 0) {
 +            av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
 +                   filename, line, key, value);
 +            exit(1);
 +        }
 +    }
 +
 +    fclose(f);
 +
 +    return 0;
 +}
 +
 +static int opt_old2new(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    char *s = av_asprintf("%s:%c", opt + 1, *opt);
 +    int ret = parse_option(o, s, arg, options);
 +    av_free(s);
 +    return ret;
 +}
 +
 +static int opt_bitrate(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    if(!strcmp(opt, "b")){
 +        av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
 +        return parse_option(o, "b:v", arg, options);
 +    }
 +    return opt_default(optctx, opt, arg);
 +}
 +
 +static int opt_qscale(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    char *s;
 +    int ret;
 +    if(!strcmp(opt, "qscale")){
 +        av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
 +        return parse_option(o, "q:v", arg, options);
 +    }
 +    s = av_asprintf("q%s", opt + 6);
 +    ret = parse_option(o, s, arg, options);
 +    av_free(s);
 +    return ret;
 +}
 +
 +static int opt_profile(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    if(!strcmp(opt, "profile")){
 +        av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
 +        return parse_option(o, "profile:v", arg, options);
 +    }
 +    return opt_default(optctx, opt, arg);
 +
 +}
 +
 +static int opt_video_filters(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "filter:v", arg, options);
 +}
 +
 +static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "filter:a", arg, options);
 +}
 +
 +static int opt_vsync(void *optctx, const char *opt, const char *arg)
 +{
 +    if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
 +    else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
 +    else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
 +    else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
 +
 +    if (video_sync_method == VSYNC_AUTO)
 +        video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
 +    return 0;
 +}
 +
 +static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
 +{
 +    av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
 +    do_deinterlace = 1;
 +    return 0;
 +}
 +
 +static int opt_timecode(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    char *tcr = av_asprintf("timecode=%s", arg);
 +    int ret = parse_option(o, "metadata:g", tcr, options);
 +    if (ret >= 0)
 +        ret = opt_default(optctx, "gop_timecode", arg);
 +    av_free(tcr);
 +    return ret;
 +}
 +
 +static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    char layout_str[32];
 +    char *stream_str;
 +    char *ac_str;
 +    int ret, channels, ac_str_size;
 +    uint64_t layout;
 +
 +    layout = av_get_channel_layout(arg);
 +    if (!layout) {
 +        av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
 +        return AVERROR(EINVAL);
 +    }
 +    snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
 +    ret = opt_default(NULL, opt, layout_str);
 +    if (ret < 0)
 +        return ret;
 +
 +    /* set 'ac' option based on channel layout */
 +    channels = av_get_channel_layout_nb_channels(layout);
 +    snprintf(layout_str, sizeof(layout_str), "%d", channels);
 +    stream_str = strchr(opt, ':');
 +    ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
 +    ac_str = av_mallocz(ac_str_size);
 +    if (!ac_str)
 +        return AVERROR(ENOMEM);
 +    av_strlcpy(ac_str, "ac", 3);
 +    if (stream_str)
 +        av_strlcat(ac_str, stream_str, ac_str_size);
 +    ret = parse_option(o, ac_str, layout_str, options);
 +    av_free(ac_str);
 +
 +    return ret;
 +}
 +
 +static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
 +{
 +    OptionsContext *o = optctx;
 +    return parse_option(o, "q:a", arg, options);
 +}
 +
 +static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
 +{
 +    filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
 +                              &nb_filtergraphs, nb_filtergraphs + 1);
 +    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
 +        return AVERROR(ENOMEM);
 +    filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
 +    filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
 +    return 0;
 +}
 +
 +void show_help_default(const char *opt, const char *arg)
 +{
 +    /* per-file options have at least one of those set */
 +    const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
 +    int show_advanced = 0, show_avoptions = 0;
 +
++    if (opt && *opt) {
 +        if (!strcmp(opt, "long"))
 +            show_advanced = 1;
 +        else if (!strcmp(opt, "full"))
 +            show_advanced = show_avoptions = 1;
 +        else
 +            av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
 +    }
 +
 +    show_usage();
 +
 +    printf("Getting help:\n"
 +           "    -h      -- print basic options\n"
 +           "    -h long -- print more options\n"
 +           "    -h full -- print all options (including all format and codec specific options, very long)\n"
 +           "    See man %s for detailed description of the options.\n"
 +           "\n", program_name);
 +
 +    show_help_options(options, "Print help / information / capabilities:",
 +                      OPT_EXIT, 0, 0);
 +
 +    show_help_options(options, "Global options (affect whole program "
 +                      "instead of just one file:",
 +                      0, per_file | OPT_EXIT | OPT_EXPERT, 0);
 +    if (show_advanced)
 +        show_help_options(options, "Advanced global options:", OPT_EXPERT,
 +                          per_file | OPT_EXIT, 0);
 +
 +    show_help_options(options, "Per-file main options:", 0,
 +                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
 +                      OPT_EXIT, per_file);
 +    if (show_advanced)
 +        show_help_options(options, "Advanced per-file options:",
 +                          OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
 +
 +    show_help_options(options, "Video options:",
 +                      OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
 +    if (show_advanced)
 +        show_help_options(options, "Advanced Video options:",
 +                          OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
 +
 +    show_help_options(options, "Audio options:",
 +                      OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
 +    if (show_advanced)
 +        show_help_options(options, "Advanced Audio options:",
 +                          OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
 +    show_help_options(options, "Subtitle options:",
 +                      OPT_SUBTITLE, 0, 0);
 +    printf("\n");
 +
 +    if (show_avoptions) {
 +        int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
 +        show_help_children(avcodec_get_class(), flags);
 +        show_help_children(avformat_get_class(), flags);
 +        show_help_children(sws_get_class(), flags);
 +        show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
 +        show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
 +    }
 +}
 +
 +void show_usage(void)
 +{
 +    av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
 +    av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
 +    av_log(NULL, AV_LOG_INFO, "\n");
 +}
 +
 +
 +static int opt_progress(void *optctx, const char *opt, const char *arg)
 +{
 +    AVIOContext *avio = NULL;
 +    int ret;
 +
 +    if (!strcmp(arg, "-"))
 +        arg = "pipe:";
 +    ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
 +    if (ret < 0) {
 +        av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
 +               arg, av_err2str(ret));
 +        return ret;
 +    }
 +    progress_avio = avio;
 +    return 0;
 +}
 +
 +#define OFFSET(x) offsetof(OptionsContext, x)
 +const OptionDef options[] = {
 +    /* main options */
 +#include "cmdutils_common_opts.h"
 +    { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
 +        "force format", "fmt" },
 +    { "i",              HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_input_file },
 +        "input file name", "filename" },
 +    { "y",              OPT_BOOL,                                    {              &file_overwrite },
 +        "overwrite output files" },
 +    { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
 +        "do not overwrite output files" },
 +    { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
 +        "codec name", "codec" },
 +    { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
 +        "codec name", "codec" },
 +    { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
 +        "preset name", "preset" },
 +    { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map },
 +        "set input stream mapping",
 +        "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
 +    { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map_channel },
 +        "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
 +    { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
 +        "set metadata information of outfile from infile",
 +        "outfile[,metadata]:infile[,metadata]" },
 +    { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
 +        "set chapters mapping", "input_file_index" },
 +    { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
 +        "record or transcode \"duration\" seconds of audio/video",
 +        "duration" },
 +    { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
 +        "set the limit file size in bytes", "limit_size" },
 +    { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
 +        "set the start time offset", "time_off" },
 +    { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
 +        "set the input ts offset", "time_off" },
 +    { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
 +        "set the input ts scale", "scale" },
 +    { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
 +        "set the recording timestamp ('now' to set the current time)", "time" },
 +    { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
 +        "add metadata", "string=string" },
 +    { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_data_frames },
 +        "set the number of data frames to record", "number" },
 +    { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
 +        "add timings for benchmarking" },
 +    { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
 +      "add timings for each task" },
 +    { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
 +      "write program-readable progress information", "url" },
 +    { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
 +      "enable or disable interaction on standard input" },
 +    { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
 +        "set max runtime in seconds", "limit" },
 +    { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
 +        "dump each input packet" },
 +    { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
 +        "when dumping packets, also dump the payload" },
 +    { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
 +        "read input at native frame rate", "" },
 +    { "target",         HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_target },
 +        "specify target file type (\"vcd\", \"svcd\", \"dvd\","
 +        " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
 +    { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
 +        "video sync method", "" },
 +    { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
 +        "audio sync method", "" },
 +    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
 +        "audio drift threshold", "threshold" },
 +    { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
 +        "copy timestamps" },
 +    { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
 +        "copy input stream time base when stream copying", "mode" },
 +    { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
 +        "finish encoding within shortest input" },
 +    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
 +        "timestamp discontinuity delta threshold", "threshold" },
 +    { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
 +        "timestamp error delta threshold", "threshold" },
 +    { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
 +        "exit on error", "error" },
 +    { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
 +        "copy initial non-keyframes" },
 +    { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC,   { .off = OFFSET(copy_prior_start) },
 +        "copy or discard frames before start time" },
 +    { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
 +        "set the number of frames to record", "number" },
 +    { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
 +        "force codec tag/fourcc", "fourcc/tag" },
 +    { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
 +        "use fixed quality scale (VBR)", "q" },
 +    { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_qscale },
 +        "use fixed quality scale (VBR)", "q" },
 +    { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_profile },
 +        "set profile", "profile" },
 +    { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
 +        "set stream filterchain", "filter_list" },
 +    { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
 +        "create a complex filtergraph", "graph_description" },
 +    { "stats",          OPT_BOOL,                                    { &print_stats },
 +        "print progress report during encoding", },
 +    { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_attach },
 +        "add an attachment to the output file", "filename" },
 +    { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
 +        "extract an attachment into a file", "filename" },
 +    { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
 +        "print timestamp debugging info" },
 +
 +    /* video options */
 +    { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_frames },
 +        "set the number of video frames to record", "number" },
 +    { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
 +        "set frame rate (Hz value, fraction or abbreviation)", "rate" },
 +    { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
 +        "set frame size (WxH or abbreviation)", "size" },
 +    { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
 +        "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
 +    { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
 +        "set pixel format", "format" },
 +    { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
 +        "set the number of bits per raw sample", "number" },
 +    { "croptop",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
 +        "Removed, use the crop filter instead", "size" },
 +    { "cropbottom",   OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
 +        "Removed, use the crop filter instead", "size" },
 +    { "cropleft",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
 +        "Removed, use the crop filter instead", "size" },
 +    { "cropright",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
 +        "Removed, use the crop filter instead", "size" },
 +    { "padtop",       OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
 +        "Removed, use the pad filter instead", "size" },
 +    { "padbottom",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
 +        "Removed, use the pad filter instead", "size" },
 +    { "padleft",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
 +        "Removed, use the pad filter instead", "size" },
 +    { "padright",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
 +        "Removed, use the pad filter instead", "size" },
 +    { "padcolor",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
 +        "Removed, use the pad filter instead", "color" },
 +    { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
 +        "deprecated use -g 1" },
 +    { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
 +        "disable video" },
 +    { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
 +        "discard threshold", "n" },
 +    { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
 +        "rate control override for specific intervals", "override" },
 +    { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_codec },
 +        "force video codec ('copy' to copy stream)", "codec" },
 +    { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
 +        "Removed" },
 +    { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
 +        "Removed" },
 +    { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_timecode },
 +        "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
 +    { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
 +        "select the pass number (1 to 3)", "n" },
 +    { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC,  { .off = OFFSET(passlogfiles) },
 +        "select two pass log file name prefix", "prefix" },
 +    { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
 +        "this option is deprecated, use the yadif filter instead" },
 +    { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
 +        "calculate PSNR of compressed frames" },
 +    { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
 +        "dump video coding statistics to file" },
 +    { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
 +        "dump video coding statistics to file", "file" },
 +    { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_filters },
 +        "video filters", "filter list" },
 +    { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
 +        "specify intra matrix coeffs", "matrix" },
 +    { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
 +        "specify inter matrix coeffs", "matrix" },
 +    { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
 +        "top=1/bottom=0/auto=-1 field first", "" },
 +    { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
 +        "intra_dc_precision", "precision" },
 +    { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE,           { .func_arg = opt_old2new },
 +        "force video tag/fourcc", "fourcc/tag" },
 +    { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
 +        "show QP histogram" },
 +    { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
 +        "force the selected framerate, disable the best supported framerate selection" },
 +    { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE,            { .func_arg = opt_streamid },
 +        "set the value of an outfile streamid", "streamIndex:value" },
 +    { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
 +        { .off = OFFSET(forced_key_frames) },
 +        "force key frames at specified timestamps", "timestamps" },
 +    { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_bitrate },
 +        "video bitrate (please use -b:v)", "bitrate" },
 +
 +    /* audio options */
 +    { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_frames },
 +        "set the number of audio frames to record", "number" },
 +    { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_qscale },
 +        "set audio quality (codec-specific)", "quality", },
 +    { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
 +        "set audio sampling rate (in Hz)", "rate" },
 +    { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
 +        "set number of audio channels", "channels" },
 +    { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
 +        "disable audio" },
 +    { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_codec },
 +        "force audio codec ('copy' to copy stream)", "codec" },
 +    { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_old2new },
 +        "force audio tag/fourcc", "fourcc/tag" },
 +    { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
 +        "change audio volume (256=normal)" , "volume" },
 +    { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
 +        "set sample format", "format" },
 +    { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_channel_layout },
 +        "set channel layout", "layout" },
 +    { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_filters },
 +        "audio filters", "filter list" },
 +
 +    /* subtitle options */
 +    { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
 +        "disable subtitle" },
 +    { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
 +        "force subtitle codec ('copy' to copy stream)", "codec" },
 +    { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE, { .func_arg = opt_old2new }
 +        , "force subtitle tag/fourcc", "fourcc/tag" },
 +    { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
 +        "fix subtitles duration" },
 +
 +    /* grab options */
 +    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
 +        "deprecated, use -channel", "channel" },
 +    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
 +        "deprecated, use -standard", "standard" },
 +    { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
 +
 +    /* muxer options */
 +    { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
 +        "set the maximum demux-decode delay", "seconds" },
 +    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
 +        "set the initial demux-decode delay", "seconds" },
 +
 +    { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
 +        "A comma-separated list of bitstream filters", "bitstream_filters" },
 +    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
 +        "deprecated", "audio bitstream_filters" },
 +    { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
 +        "deprecated", "video bitstream_filters" },
 +
 +    { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
 +        "set the audio options to the indicated preset", "preset" },
 +    { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
 +        "set the video options to the indicated preset", "preset" },
 +    { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
 +        "set the subtitle options to the indicated preset", "preset" },
 +    { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE,                { .func_arg = opt_preset },
 +        "set options from indicated preset file", "filename" },
 +    /* data codec support */
 +    { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
 +        "force data codec ('copy' to copy stream)", "codec" },
 +    { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
 +        "disable data" },
 +
 +    { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
 +        "generic catch all option", "" },
 +    { NULL, },
 +};
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -133,11 -155,6 +149,7 @@@ AVFilter avfilter_af_aformat = 
      .query_formats = query_formats,
      .priv_size     = sizeof(AFormatContext),
  
-     .inputs        = (const AVFilterPad[]) {{ .name            = "default",
-                                               .type            = AVMEDIA_TYPE_AUDIO, },
-                                             { .name = NULL}},
-     .outputs       = (const AVFilterPad[]) {{ .name            = "default",
-                                               .type            = AVMEDIA_TYPE_AUDIO},
-                                             { .name = NULL}},
-     .priv_class = &aformat_class,
+     .inputs        = avfilter_af_aformat_inputs,
+     .outputs       = avfilter_af_aformat_outputs,
++    .priv_class    = &aformat_class,
  };
@@@ -552,10 -569,5 +562,6 @@@ AVFilter avfilter_af_amix = 
      .query_formats  = query_formats,
  
      .inputs    = NULL,
-     .outputs   = (const AVFilterPad[]) {{ .name          = "default",
-                                           .type          = AVMEDIA_TYPE_AUDIO,
-                                           .config_props  = config_output,
-                                           .request_frame = request_frame },
-                                         { .name = NULL}},
+     .outputs   = avfilter_af_amix_outputs,
 +    .priv_class = &amix_class,
  };
Simple merge
@@@ -242,14 -267,6 +261,7 @@@ AVFilter avfilter_af_asyncts = 
  
      .priv_size   = sizeof(ASyncContext),
  
-     .inputs      = (const AVFilterPad[]) {{ .name           = "default",
-                                             .type           = AVMEDIA_TYPE_AUDIO,
-                                             .filter_samples = filter_samples },
-                                           { NULL }},
-     .outputs     = (const AVFilterPad[]) {{ .name           = "default",
-                                             .type           = AVMEDIA_TYPE_AUDIO,
-                                             .config_props   = config_props,
-                                             .request_frame  = request_frame },
-                                           { NULL }},
+     .inputs      = avfilter_af_asyncts_inputs,
+     .outputs     = avfilter_af_asyncts_outputs,
 +    .priv_class = &asyncts_class,
  };
@@@ -385,6 -386,24 +385,25 @@@ static int channelmap_config_input(AVFi
      return err;
  }
  
+ static const AVFilterPad avfilter_af_channelmap_inputs[] = {
+     {
+         .name           = "default",
+         .type           = AVMEDIA_TYPE_AUDIO,
++        .min_perms      = AV_PERM_READ | AV_PERM_WRITE,
+         .filter_samples = channelmap_filter_samples,
+         .config_props   = channelmap_config_input
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_af_channelmap_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_AUDIO
+     },
+     { NULL }
+ };
  AVFilter avfilter_af_channelmap = {
      .name          = "channelmap",
      .description   = NULL_IF_CONFIG_SMALL("Remap audio channels."),
      .query_formats = channelmap_query_formats,
      .priv_size     = sizeof(ChannelMapContext),
  
-     .inputs        = (const AVFilterPad[]) {{ .name            = "default",
-                                               .type            = AVMEDIA_TYPE_AUDIO,
-                                               .min_perms       = AV_PERM_READ | AV_PERM_WRITE,
-                                               .filter_samples  = channelmap_filter_samples,
-                                               .config_props    = channelmap_config_input },
-                                             { .name = NULL }},
-     .outputs       = (const AVFilterPad[]) {{ .name            = "default",
-                                               .type            = AVMEDIA_TYPE_AUDIO },
-                                             { .name = NULL }},
-     .priv_class = &channelmap_class,
+     .inputs        = avfilter_af_channelmap_inputs,
+     .outputs       = avfilter_af_channelmap_outputs,
++    .priv_class    = &channelmap_class,
  };
@@@ -138,10 -153,6 +147,7 @@@ AVFilter avfilter_af_channelsplit = 
      .init           = init,
      .query_formats  = query_formats,
  
-     .inputs  = (const AVFilterPad[]){{ .name           = "default",
-                                        .type           = AVMEDIA_TYPE_AUDIO,
-                                        .filter_samples = filter_samples, },
-                                      { NULL }},
+     .inputs  = avfilter_af_channelsplit_inputs,
      .outputs = NULL,
 +    .priv_class = &channelsplit_class,
  };
@@@ -495,10 -506,5 +505,6 @@@ AVFilter avfilter_af_join = 
      .query_formats  = join_query_formats,
  
      .inputs  = NULL,
-     .outputs = (const AVFilterPad[]){{ .name          = "default",
-                                        .type          = AVMEDIA_TYPE_AUDIO,
-                                        .config_props  = join_config_output,
-                                        .request_frame = join_request_frame, },
-                                      { NULL }},
+     .outputs = avfilter_af_join_outputs,
 +    .priv_class = &join_class,
  };
Simple merge
@@@ -100,38 -79,29 +100,44 @@@ static int config_props(AVFilterLink *o
      return 0;
  }
  
 -static int request_frame(AVFilterLink *link)
 +static int request_frame(AVFilterLink *outlink)
  {
 -    return -1;
 +    ANullContext *null = outlink->src->priv;
 +    AVFilterBufferRef *samplesref;
 +
 +    samplesref =
 +        ff_get_audio_buffer(outlink, AV_PERM_WRITE, null->nb_samples);
 +    samplesref->pts = null->pts;
 +    samplesref->pos = -1;
 +    samplesref->audio->channel_layout = null->channel_layout;
 +    samplesref->audio->sample_rate = outlink->sample_rate;
 +
 +    ff_filter_samples(outlink, avfilter_ref_buffer(samplesref, ~0));
 +    avfilter_unref_buffer(samplesref);
 +
 +    null->pts += null->nb_samples;
 +    return 0;
  }
  
+ static const AVFilterPad avfilter_asrc_anullsrc_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_AUDIO,
+         .config_props  = config_props,
+         .request_frame = request_frame,
+     },
+     { NULL }
+ };
  AVFilter avfilter_asrc_anullsrc = {
      .name        = "anullsrc",
 -    .description = NULL_IF_CONFIG_SMALL("Null audio source, never return audio frames."),
 +    .description = NULL_IF_CONFIG_SMALL("Null audio source, return empty audio frames."),
  
      .init        = init,
      .priv_size   = sizeof(ANullContext),
  
      .inputs      = NULL,
  
-     .outputs     = (const AVFilterPad[]) {{ .name = "default",
-                                             .type = AVMEDIA_TYPE_AUDIO,
-                                             .config_props = config_props,
-                                             .request_frame = request_frame, },
-                                           { .name = NULL}},
+     .outputs     = avfilter_asrc_anullsrc_outputs,
 +    .priv_class = &anullsrc_class,
  };
@@@ -140,12 -140,19 +140,23 @@@ int ff_buffersink_read_samples_compat(A
      return ret;
  }
  
+ static const AVFilterPad avfilter_vsink_buffer_inputs[] = {
+     {
+         .name        = "default",
+         .type        = AVMEDIA_TYPE_VIDEO,
+         .start_frame = start_frame,
+         .min_perms   = AV_PERM_READ,
+         .needs_fifo  = 1
+     },
+     { NULL }
+ };
  AVFilter avfilter_vsink_buffer = {
 +#if AV_HAVE_INCOMPATIBLE_FORK_ABI
      .name      = "buffersink",
 +#else
 +    .name      = "buffersink_old",
 +#endif
      .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),
      .priv_size = sizeof(BufferSinkContext),
      .uninit    = uninit,
      .outputs   = NULL,
  };
  
+ static const AVFilterPad avfilter_asink_abuffer_inputs[] = {
+     {
+         .name           = "default",
+         .type           = AVMEDIA_TYPE_AUDIO,
+         .filter_samples = start_frame,
+         .min_perms      = AV_PERM_READ,
+         .needs_fifo     = 1
+     },
+     { NULL }
+ };
  AVFilter avfilter_asink_abuffer = {
 +#if AV_HAVE_INCOMPATIBLE_FORK_ABI
      .name      = "abuffersink",
 +#else
 +    .name      = "abuffersink_old",
 +#endif
      .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them available to the end of the filter graph."),
      .priv_size = sizeof(BufferSinkContext),
      .uninit    = uninit,
@@@ -410,15 -376,20 +421,21 @@@ AVFilter avfilter_vsrc_buffer = 
      .uninit    = uninit,
  
      .inputs    = NULL,
-     .outputs   = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .request_frame   = request_frame,
-                                           .poll_frame      = poll_frame,
-                                           .config_props    = config_props, },
-                                         { .name = NULL}},
+     .outputs   = avfilter_vsrc_buffer_outputs,
 +    .priv_class = &buffer_class,
  };
  
+ static const AVFilterPad avfilter_asrc_abuffer_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_AUDIO,
+         .request_frame = request_frame,
+         .poll_frame    = poll_frame,
+         .config_props  = config_props,
+     },
+     { NULL }
+ };
  AVFilter avfilter_asrc_abuffer = {
      .name          = "abuffer",
      .description   = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
      .uninit    = uninit,
  
      .inputs    = NULL,
-     .outputs   = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_AUDIO,
-                                           .request_frame   = request_frame,
-                                           .poll_frame      = poll_frame,
-                                           .config_props    = config_props, },
-                                         { .name = NULL}},
+     .outputs   = avfilter_asrc_abuffer_outputs,
 +    .priv_class = &abuffer_class,
  };
index 023dc1e,0000000..5a58ce3
mode 100644,000000..100644
--- /dev/null
@@@ -1,237 -1,0 +1,249 @@@
-     .inputs    = (const AVFilterPad[]) {{ .name             = "default",
-                                           .type             = AVMEDIA_TYPE_VIDEO,
-                                           .get_video_buffer = ff_null_get_video_buffer,
-                                           .config_props     = config_input,
-                                           .start_frame      = filter_frame, },
-                                         { .name = NULL }},
-     .outputs   = (const AVFilterPad[]) {{ .name             = "default",
-                                           .type             = AVMEDIA_TYPE_VIDEO, },
-                                         { .name = NULL}},
 +/*
 + * 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
 + */
 +
 +/* #define DEBUG */
 +
 +#include "libavutil/eval.h"
 +#include "libavutil/internal.h"
 +#include "libavutil/mathematics.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
 +    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_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_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))
 +
 +static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
 +{
 +    SetPTSContext *setpts = inlink->dst->priv;
 +    double d;
 +    AVFilterBufferRef *outpicref = avfilter_ref_buffer(inpicref, ~0);
 +
 +    if (!outpicref)
 +        return AVERROR(ENOMEM);
 +
 +    if (isnan(setpts->var_values[VAR_STARTPTS])) {
 +        setpts->var_values[VAR_STARTPTS] = TS2D(inpicref->pts);
 +        setpts->var_values[VAR_STARTT  ] = TS2T(inpicref->pts, inlink->time_base);
 +    }
 +    setpts->var_values[VAR_PTS       ] = TS2D(inpicref->pts);
 +    setpts->var_values[VAR_T         ] = TS2T(inpicref->pts, inlink->time_base);
 +    setpts->var_values[VAR_POS       ] = inpicref->pos == -1 ? NAN : inpicref->pos;
 +
 +    switch (inlink->type) {
 +    case AVMEDIA_TYPE_VIDEO:
 +        setpts->var_values[VAR_INTERLACED] = inpicref->video->interlaced;
 +        break;
 +
 +    case AVMEDIA_TYPE_AUDIO:
 +        setpts->var_values[VAR_NB_SAMPLES] = inpicref->audio->nb_samples;
 +        break;
 +    }
 +
 +    d = av_expr_eval(setpts->expr, setpts->var_values, NULL);
 +    outpicref->pts = D2TS(d);
 +
 +    setpts->var_values[VAR_PREV_INPTS ] = TS2D(inpicref ->pts);
 +    setpts->var_values[VAR_PREV_INT   ] = TS2T(inpicref ->pts, inlink->time_base);
 +    setpts->var_values[VAR_PREV_OUTPTS] = TS2D(outpicref->pts);
 +    setpts->var_values[VAR_PREV_OUTT]   = TS2T(outpicref->pts, inlink->time_base);
 +
 +    av_dlog(inlink->dst,
 +            "n:%"PRId64" interlaced:%d nb_samples:%d nb_consumed_samples:%d "
 +            "pos:%"PRId64" pts:%"PRId64" t:%f -> pts:%"PRId64" t:%f\n",
 +            (int64_t)setpts->var_values[VAR_N],
 +            (int)setpts->var_values[VAR_INTERLACED],
 +            (int)setpts->var_values[VAR_NB_SAMPLES],
 +            (int)setpts->var_values[VAR_NB_CONSUMED_SAMPLES],
 +            (int64_t)setpts->var_values[VAR_POS],
 +            (int64_t)setpts->var_values[VAR_PREV_INPTS],
 +            setpts->var_values[VAR_PREV_INT],
 +            (int64_t)setpts->var_values[VAR_PREV_OUTPTS],
 +            setpts->var_values[VAR_PREV_OUTT]);
 +
 +    setpts->var_values[VAR_N] += 1.0;
 +    if (setpts->type == AVMEDIA_TYPE_AUDIO) {
 +        setpts->var_values[VAR_NB_CONSUMED_SAMPLES] += inpicref->audio->nb_samples;
 +        return ff_filter_samples(inlink->dst->outputs[0], outpicref);
 +    } else
 +        return ff_start_frame   (inlink->dst->outputs[0], outpicref);
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    SetPTSContext *setpts = ctx->priv;
 +    av_expr_free(setpts->expr);
 +    setpts->expr = NULL;
 +}
 +
 +#if CONFIG_ASETPTS_FILTER
 +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 = (const AVFilterPad[]) {
 +        {
 +            .name             = "default",
 +            .type             = AVMEDIA_TYPE_AUDIO,
 +            .get_audio_buffer = ff_null_get_audio_buffer,
 +            .config_props     = config_input,
 +            .filter_samples   = filter_frame,
 +        },
 +        { .name = NULL }
 +    },
 +    .outputs = (const AVFilterPad[]) {
 +        {
 +            .name             = "default",
 +            .type             = AVMEDIA_TYPE_AUDIO,
 +        },
 +        { .name = NULL }
 +    },
 +};
 +#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,
++        .start_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 */
index e6c16aa,0000000..f42a15c
mode 100644,000000..100644
--- /dev/null
@@@ -1,186 -1,0 +1,194 @@@
-     .inputs    = (const AVFilterPad[]) {
-         { .name             = "default",
-           .type             = AVMEDIA_TYPE_VIDEO,
-           .get_video_buffer = ff_null_get_video_buffer,
-           .start_frame      = start_frame,
-           .end_frame        = ff_null_end_frame },
-         { .name = NULL }
-     },
-     .outputs   = (const AVFilterPad[]) {
-         { .name            = "default",
-           .type            = AVMEDIA_TYPE_VIDEO,
-           .config_props    = config_output_props, },
-         { .name = NULL}
-     },
 +/*
 + * Copyright (c) 2010 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
 + * Set timebase for the output link.
 + */
 +
 +#include <inttypes.h>
 +#include <stdio.h>
 +
 +#include "libavutil/avstring.h"
 +#include "libavutil/eval.h"
 +#include "libavutil/internal.h"
 +#include "libavutil/mathematics.h"
 +#include "libavutil/rational.h"
 +#include "avfilter.h"
 +#include "internal.h"
 +#include "audio.h"
 +#include "video.h"
 +
 +static const char *const var_names[] = {
 +    "AVTB",   /* default timebase 1/AV_TIME_BASE */
 +    "intb",   /* input timebase */
 +    "sr",     /* sample rate */
 +    NULL
 +};
 +
 +enum var_name {
 +    VAR_AVTB,
 +    VAR_INTB,
 +    VAR_SR,
 +    VAR_VARS_NB
 +};
 +
 +typedef struct {
 +    char tb_expr[256];
 +    double var_values[VAR_VARS_NB];
 +} SetTBContext;
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    SetTBContext *settb = ctx->priv;
 +    av_strlcpy(settb->tb_expr, "intb", sizeof(settb->tb_expr));
 +
 +    if (args)
 +        sscanf(args, "%255[^:]", settb->tb_expr);
 +
 +    return 0;
 +}
 +
 +static int config_output_props(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    SetTBContext *settb = ctx->priv;
 +    AVFilterLink *inlink = ctx->inputs[0];
 +    AVRational time_base;
 +    int ret;
 +    double res;
 +
 +    settb->var_values[VAR_AVTB] = av_q2d(AV_TIME_BASE_Q);
 +    settb->var_values[VAR_INTB] = av_q2d(inlink->time_base);
 +    settb->var_values[VAR_SR]   = inlink->sample_rate;
 +
 +    outlink->w = inlink->w;
 +    outlink->h = inlink->h;
 +
 +    if ((ret = av_expr_parse_and_eval(&res, settb->tb_expr, var_names, settb->var_values,
 +                                      NULL, NULL, NULL, NULL, NULL, 0, NULL)) < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Invalid expression '%s' for timebase.\n", settb->tb_expr);
 +        return ret;
 +    }
 +    time_base = av_d2q(res, INT_MAX);
 +    if (time_base.num <= 0 || time_base.den <= 0) {
 +        av_log(ctx, AV_LOG_ERROR,
 +               "Invalid non-positive values for the timebase num:%d or den:%d.\n",
 +               time_base.num, time_base.den);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    outlink->time_base = time_base;
 +    av_log(outlink->src, AV_LOG_VERBOSE, "tb:%d/%d -> tb:%d/%d\n",
 +           inlink ->time_base.num, inlink ->time_base.den,
 +           outlink->time_base.num, outlink->time_base.den);
 +
 +    return 0;
 +}
 +
 +static int start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    AVFilterLink *outlink = ctx->outputs[0];
 +
 +    if (av_cmp_q(inlink->time_base, outlink->time_base)) {
 +        int64_t orig_pts = picref->pts;
 +        picref->pts = av_rescale_q(picref->pts, inlink->time_base, outlink->time_base);
 +        av_log(ctx, AV_LOG_DEBUG, "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
 +               inlink ->time_base.num, inlink ->time_base.den, orig_pts,
 +               outlink->time_base.num, outlink->time_base.den, picref->pts);
 +    }
 +    inlink->cur_buf = NULL;
 +
 +    return ff_start_frame(outlink, picref);
 +}
 +
 +static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    AVFilterLink *outlink = ctx->outputs[0];
 +
 +    if (av_cmp_q(inlink->time_base, outlink->time_base)) {
 +        int64_t orig_pts = samplesref->pts;
 +        samplesref->pts = av_rescale_q(samplesref->pts, inlink->time_base, outlink->time_base);
 +        av_log(ctx, AV_LOG_DEBUG, "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
 +               inlink ->time_base.num, inlink ->time_base.den, orig_pts,
 +               outlink->time_base.num, outlink->time_base.den, samplesref->pts);
 +    }
 +
 +    return ff_filter_samples(outlink, samplesref);
 +}
 +
 +#if CONFIG_SETTB_FILTER
++static const AVFilterPad avfilter_vf_settb_inputs[] = {
++    {
++        .name             = "default",
++        .type             = AVMEDIA_TYPE_VIDEO,
++        .get_video_buffer = ff_null_get_video_buffer,
++        .start_frame      = start_frame,
++        .end_frame        = ff_null_end_frame
++    },
++    { NULL }
++};
++
++static const AVFilterPad avfilter_vf_settb_outputs[] = {
++    {
++        .name         = "default",
++        .type         = AVMEDIA_TYPE_VIDEO,
++        .config_props = config_output_props,
++    },
++    { NULL }
++};
++
 +AVFilter avfilter_vf_settb = {
 +    .name      = "settb",
 +    .description = NULL_IF_CONFIG_SMALL("Set timebase for the video output link."),
 +    .init      = init,
 +
 +    .priv_size = sizeof(SetTBContext),
 +
++    .inputs    = avfilter_vf_settb_inputs,
++    .outputs   = avfilter_vf_settb_outputs,
 +};
 +#endif
 +
 +#if CONFIG_ASETTB_FILTER
 +AVFilter avfilter_af_asettb = {
 +    .name      = "asettb",
 +    .description = NULL_IF_CONFIG_SMALL("Set timebase for the audio output link."),
 +    .init      = init,
 +
 +    .priv_size = sizeof(SetTBContext),
 +
 +    .inputs    = (const AVFilterPad[]) {
 +        { .name             = "default",
 +          .type             = AVMEDIA_TYPE_AUDIO,
 +          .get_audio_buffer = ff_null_get_audio_buffer,
 +          .filter_samples   = filter_samples, },
 +        { .name = NULL }
 +    },
 +    .outputs   = (const AVFilterPad[]) {
 +        { .name            = "default",
 +          .type            = AVMEDIA_TYPE_AUDIO,
 +          .config_props    = config_output_props, },
 +        { .name = NULL}
 +    },
 +};
 +#endif
@@@ -267,6 -267,28 +267,28 @@@ static int request_frame(AVFilterLink *
      return ret;
  }
  
 -        .rej_perms        = AV_PERM_REUSE2,
+ static const AVFilterPad avfilter_vf_fifo_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .get_video_buffer = ff_null_get_video_buffer,
+         .start_frame      = add_to_queue,
+         .draw_slice       = draw_slice,
+         .end_frame        = end_frame,
++        .min_perms        = AV_PERM_PRESERVE,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_fifo_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_VIDEO,
+         .request_frame = request_frame,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_fifo = {
      .name      = "fifo",
      .description = NULL_IF_CONFIG_SMALL("Buffer input images and send them when they are requested."),
  
      .priv_size = sizeof(FifoContext),
  
-     .inputs    = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .get_video_buffer= ff_null_get_video_buffer,
-                                           .start_frame     = add_to_queue,
-                                           .draw_slice      = draw_slice,
-                                           .end_frame       = end_frame,
-                                           .min_perms       = AV_PERM_PRESERVE, },
-                                         { .name = NULL}},
-     .outputs   = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .request_frame   = request_frame, },
-                                         { .name = NULL}},
+     .inputs    = avfilter_vf_fifo_inputs,
+     .outputs   = avfilter_vf_fifo_outputs,
+ };
+ static const AVFilterPad avfilter_af_afifo_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_AUDIO,
+         .get_audio_buffer = ff_null_get_audio_buffer,
+         .filter_samples   = add_to_queue,
 -        .rej_perms        = AV_PERM_REUSE2,
++        .min_perms        = AV_PERM_PRESERVE,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_af_afifo_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_AUDIO,
+         .request_frame = request_frame,
+     },
+     { NULL }
  };
  
  AVFilter avfilter_af_afifo = {
@@@ -119,9 -110,21 +119,21 @@@ static int end_frame(AVFilterLink *inli
      return ret;
  }
  
+ static const AVFilterPad avfilter_vf_split_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .get_video_buffer = ff_null_get_video_buffer,
+         .start_frame      = start_frame,
+         .draw_slice       = draw_slice,
+         .end_frame        = end_frame,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_split = {
      .name      = "split",
 -    .description = NULL_IF_CONFIG_SMALL("Pass on the input to two outputs."),
 +    .description = NULL_IF_CONFIG_SMALL("Pass on the input video to N outputs."),
  
      .init   = split_init,
      .uninit = split_uninit,
Simple merge
Simple merge
@@@ -328,10 -331,28 +328,30 @@@ static int end_frame(AVFilterLink *inli
                w[plane], h[plane], boxblur->radius[plane], boxblur->power[plane],
                boxblur->temp);
  
 -    return ff_draw_slice(outlink, y0, h0, slice_dir);
 +    ff_draw_slice(outlink, 0, inlink->h, 1);
 +    return ff_end_frame(outlink);
  }
  
 -        .draw_slice   = draw_slice,
+ static const AVFilterPad avfilter_vf_boxblur_inputs[] = {
+     {
+         .name         = "default",
+         .type         = AVMEDIA_TYPE_VIDEO,
+         .config_props = config_input,
++        .draw_slice   = null_draw_slice,
++        .end_frame    = end_frame,
+         .min_perms    = AV_PERM_READ
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_boxblur_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_boxblur = {
      .name          = "boxblur",
      .description   = NULL_IF_CONFIG_SMALL("Blur the input."),
Simple merge
Simple merge
Simple merge
@@@ -245,6 -251,28 +245,27 @@@ static int end_frame(AVFilterLink *inli
      return 0;
  }
  
 -        .rej_perms        = AV_PERM_PRESERVE
+ static const AVFilterPad avfilter_vf_delogo_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .get_video_buffer = ff_null_get_video_buffer,
+         .start_frame      = ff_inplace_start_frame,
+         .draw_slice       = null_draw_slice,
+         .end_frame        = end_frame,
+         .min_perms        = AV_PERM_WRITE | AV_PERM_READ,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_delogo_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_delogo = {
      .name          = "delogo",
      .description   = NULL_IF_CONFIG_SMALL("Remove logo from input video."),
@@@ -124,6 -124,29 +124,28 @@@ static int draw_slice(AVFilterLink *inl
      return ff_draw_slice(inlink->dst->outputs[0], y0, h, 1);
  }
  
 -        .rej_perms        = AV_PERM_PRESERVE
+ static const AVFilterPad avfilter_vf_drawbox_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .config_props     = config_input,
+         .get_video_buffer = ff_null_get_video_buffer,
+         .start_frame      = ff_null_start_frame,
+         .draw_slice       = draw_slice,
+         .end_frame        = ff_null_end_frame,
+         .min_perms        = AV_PERM_WRITE | AV_PERM_READ,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_drawbox_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_drawbox = {
      .name      = "drawbox",
      .description = NULL_IF_CONFIG_SMALL("Draw a colored box on the input video."),
@@@ -810,6 -879,30 +810,29 @@@ static int end_frame(AVFilterLink *inli
      return 0;
  }
  
 -        .start_frame      = start_frame,
+ static const AVFilterPad avfilter_vf_drawtext_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .get_video_buffer = ff_null_get_video_buffer,
 -        .rej_perms = AV_PERM_PRESERVE
++        .start_frame      = ff_null_start_frame,
+         .draw_slice       = null_draw_slice,
+         .end_frame        = end_frame,
+         .config_props     = config_input,
+         .min_perms        = AV_PERM_WRITE |
+                             AV_PERM_READ,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_drawtext_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_drawtext = {
      .name          = "drawtext",
      .description   = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),
      .uninit        = uninit,
      .query_formats = query_formats,
  
-     .inputs    = (const AVFilterPad[]) {{ .name             = "default",
-                                           .type             = AVMEDIA_TYPE_VIDEO,
-                                           .get_video_buffer = ff_null_get_video_buffer,
-                                           .start_frame      = ff_null_start_frame,
-                                           .draw_slice       = null_draw_slice,
-                                           .end_frame        = end_frame,
-                                           .config_props     = config_input,
-                                           .min_perms        = AV_PERM_WRITE |
-                                                               AV_PERM_READ },
-                                         { .name = NULL}},
-     .outputs   = (const AVFilterPad[]) {{ .name             = "default",
-                                           .type             = AVMEDIA_TYPE_VIDEO, },
-                                         { .name = NULL}},
+     .inputs    = avfilter_vf_drawtext_inputs,
+     .outputs   = avfilter_vf_drawtext_outputs,
 +    .process_command = command,
 +    .priv_class = &drawtext_class,
  };
@@@ -276,25 -154,36 +276,37 @@@ static int end_frame(AVFilterLink *inli
      return ret;
  }
  
 -        .rej_perms        = AV_PERM_PRESERVE,
+ static const AVFilterPad avfilter_vf_fade_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .config_props     = config_props,
+         .get_video_buffer = ff_null_get_video_buffer,
+         .start_frame      = ff_null_start_frame,
+         .draw_slice       = draw_slice,
+         .end_frame        = end_frame,
+         .min_perms        = AV_PERM_READ | AV_PERM_WRITE,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_fade_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_fade = {
      .name          = "fade",
 -    .description   = NULL_IF_CONFIG_SMALL("Fade in/out input video"),
 +    .description   = NULL_IF_CONFIG_SMALL("Fade in/out input video."),
      .init          = init,
 +    .uninit        = uninit,
      .priv_size     = sizeof(FadeContext),
      .query_formats = query_formats,
  
-     .inputs    = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .config_props    = config_props,
-                                           .get_video_buffer = ff_null_get_video_buffer,
-                                           .start_frame      = ff_null_start_frame,
-                                           .draw_slice      = draw_slice,
-                                           .end_frame       = end_frame,
-                                           .min_perms       = AV_PERM_READ | AV_PERM_WRITE },
-                                         { .name = NULL}},
-     .outputs   = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO, },
-                                         { .name = NULL}},
+     .inputs    = avfilter_vf_fade_inputs,
+     .outputs   = avfilter_vf_fade_outputs,
 +    .priv_class = &fade_class,
  };
@@@ -234,6 -234,29 +234,28 @@@ static int end_frame(AVFilterLink *inli
      return ff_end_frame(outlink);
  }
  
 -        .min_perms        = AV_PERM_READ,
 -        .rej_perms        = AV_PERM_REUSE2 | AV_PERM_PRESERVE,
+ static const AVFilterPad avfilter_vf_fieldorder_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .config_props     = config_input,
+         .start_frame      = start_frame,
+         .get_video_buffer = get_video_buffer,
+         .draw_slice       = draw_slice,
+         .end_frame        = end_frame,
++        .min_perms        = AV_PERM_READ | AV_PERM_PRESERVE,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_fieldorder_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_fieldorder = {
      .name          = "fieldorder",
      .description   = NULL_IF_CONFIG_SMALL("Set the field order."),
Simple merge
@@@ -279,6 -278,27 +279,29 @@@ static int null_draw_slice(AVFilterLin
      return 0;
  }
  
+ static const AVFilterPad avfilter_vf_fps_inputs[] = {
+     {
+         .name        = "default",
+         .type        = AVMEDIA_TYPE_VIDEO,
++        .min_perms   = AV_PERM_READ | AV_PERM_PRESERVE,
+         .start_frame = null_start_frame,
+         .draw_slice  = null_draw_slice,
+         .end_frame   = end_frame,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_fps_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_VIDEO,
++        .rej_perms     = AV_PERM_WRITE,
+         .request_frame = request_frame,
+         .config_props  = config_props
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_fps = {
      .name        = "fps",
      .description = NULL_IF_CONFIG_SMALL("Force constant framerate"),
  
      .priv_size = sizeof(FPSContext),
  
-     .inputs    = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .min_perms       = AV_PERM_READ | AV_PERM_PRESERVE,
-                                           .start_frame     = null_start_frame,
-                                           .draw_slice      = null_draw_slice,
-                                           .end_frame       = end_frame, },
-                                         { .name = NULL}},
-     .outputs   = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .rej_perms       = AV_PERM_WRITE,
-                                           .request_frame   = request_frame,
-                                           .config_props    = config_props},
-                                         { .name = NULL}},
+     .inputs    = avfilter_vf_fps_inputs,
+     .outputs   = avfilter_vf_fps_outputs,
 +    .priv_class = &fps_class,
  };
Simple merge
Simple merge
@@@ -165,6 -148,25 +165,26 @@@ static int draw_slice(AVFilterLink *inl
      return ff_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
  }
  
+ static const AVFilterPad avfilter_vf_hflip_inputs[] = {
+     {
+         .name         = "default",
+         .type         = AVMEDIA_TYPE_VIDEO,
++        .start_frame  = start_frame,
+         .draw_slice   = draw_slice,
+         .config_props = config_props,
+         .min_perms    = AV_PERM_READ,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_hflip_outputs[] = {
+     {
+         .name = "default",
+         .type = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_hflip = {
      .name      = "hflip",
      .description = NULL_IF_CONFIG_SMALL("Horizontally flip the input video."),
Simple merge
Simple merge
Simple merge
@@@ -523,90 -301,115 +523,124 @@@ static int start_frame_main(AVFilterLin
      return 0;
  }
  
 -static int output_frame(AVFilterContext *ctx)
 +static int draw_slice_main(AVFilterLink *inlink, int y, int h, int slice_dir)
  {
 -    OverlayContext *s = ctx->priv;
 +    AVFilterContext *ctx = inlink->dst;
 +    OverlayContext *over = ctx->priv;
      AVFilterLink *outlink = ctx->outputs[0];
 -    int ret = ff_start_frame(outlink, s->main);
 -    if (ret >= 0)
 -        ret = ff_draw_slice(outlink, 0, outlink->h, 1);
 -    if (ret >= 0)
 -        ret = ff_end_frame(outlink);
 -    s->main = NULL;
 -
 -    return ret;
 +    AVFilterBufferRef *outpicref = outlink->out_buf;
 +
 +    if (!outpicref)
 +        return 0;
 +    if (over->overpicref &&
 +        y + h > over->y && y < over->y + over->overpicref->video->h) {
 +        blend_slice(ctx, outpicref, over->overpicref, over->x, over->y,
 +                    over->overpicref->video->w, over->overpicref->video->h,
 +                    y, outpicref->video->w, h);
 +    }
 +    return ff_draw_slice(outlink, y, h, slice_dir);
  }
  
 -static int handle_overlay_eof(AVFilterContext *ctx)
 +static int end_frame_main(AVFilterLink *inlink)
  {
 -    OverlayContext *s = ctx->priv;
 -    if (s->over_prev)
 -        blend_frame(ctx, s->main, s->over_prev, s->x, s->y);
 -    return output_frame(ctx);
 +    AVFilterContext *ctx = inlink->dst;
 +    AVFilterLink *outlink = ctx->outputs[0];
 +    AVFilterBufferRef *outpicref = outlink->out_buf;
 +    flush_frames(ctx);
 +
 +    if (!outpicref)
 +        return 0;
 +    return ff_end_frame(ctx->outputs[0]);
  }
  
 -static int request_frame(AVFilterLink *outlink)
 +static int start_frame_over(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
  {
 -    AVFilterContext *ctx = outlink->src;
 -    OverlayContext    *s = ctx->priv;
 -    AVRational tb_main = ctx->inputs[MAIN]->time_base;
 -    AVRational tb_over = ctx->inputs[OVERLAY]->time_base;
 -    int ret = 0;
 +    return 0;
 +}
  
 -    /* get a frame on the main input */
 -    if (!s->main) {
 -        ret = ff_request_frame(ctx->inputs[MAIN]);
 -        if (ret < 0)
 -            return ret;
 -    }
 +static int end_frame_over(AVFilterLink *inlink)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    OverlayContext *over = ctx->priv;
 +    AVFilterBufferRef *inpicref = inlink->cur_buf;
 +    int ret;
  
 -    /* get a new frame on the overlay input, on EOF
 -     * reuse previous */
 -    if (!s->over_next) {
 -        ret = ff_request_frame(ctx->inputs[OVERLAY]);
 -        if (ret == AVERROR_EOF)
 -           return handle_overlay_eof(ctx);
 -        else if (ret < 0)
 -            return ret;
 -    }
 +    inlink->cur_buf = NULL;
  
 -    while (s->main->pts != AV_NOPTS_VALUE &&
 -           s->over_next->pts != AV_NOPTS_VALUE &&
 -           av_compare_ts(s->over_next->pts, tb_over, s->main->pts, tb_main) < 0) {
 -        avfilter_unref_bufferp(&s->over_prev);
 -        FFSWAP(AVFilterBufferRef*, s->over_prev, s->over_next);
 +    if ((ret = flush_frames(ctx)) < 0)
 +        return ret;
 +    ff_bufqueue_add(ctx, &over->queue_over, inpicref);
 +    ret = try_push_frame(ctx);
 +    return ret == AVERROR(EAGAIN) ? 0 : ret;
 +}
  
 -        ret = ff_request_frame(ctx->inputs[OVERLAY]);
 -        if (ret == AVERROR_EOF)
 -            return handle_overlay_eof(ctx);
 -        else if (ret < 0)
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    OverlayContext *over = ctx->priv;
 +    int input, ret;
 +
 +    if (!try_push_frame(ctx))
 +        return 0;
 +    over->frame_requested = 1;
 +    while (over->frame_requested) {
 +        /* TODO if we had a frame duration, we could guess more accurately */
 +        input = !over->overlay_eof && (over->queue_main.available ||
 +                                       over->queue_over.available < 2) ?
 +                OVERLAY : MAIN;
 +        ret = ff_request_frame(ctx->inputs[input]);
 +        /* EOF on main is reported immediately */
 +        if (ret == AVERROR_EOF && input == OVERLAY) {
 +            over->overlay_eof = 1;
 +            if ((ret = try_start_next_frame(ctx)) != AVERROR(EAGAIN))
 +                return ret;
 +            ret = 0; /* continue requesting frames on main */
 +        }
 +        if (ret < 0)
              return ret;
      }
 +    return 0;
 +}
  
 -    if (s->main->pts == AV_NOPTS_VALUE ||
 -        s->over_next->pts == AV_NOPTS_VALUE ||
 -        !av_compare_ts(s->over_next->pts, tb_over, s->main->pts, tb_main)) {
 -        blend_frame(ctx, s->main, s->over_next, s->x, s->y);
 -        avfilter_unref_bufferp(&s->over_prev);
 -        FFSWAP(AVFilterBufferRef*, s->over_prev, s->over_next);
 -    } else if (s->over_prev) {
 -        blend_frame(ctx, s->main, s->over_prev, s->x, s->y);
 -    }
 -
 -    return output_frame(ctx);
 +static int null_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
 +{
 +    return 0;
  }
  
 -        .start_frame  = null_start_frame,
+ static const AVFilterPad avfilter_vf_overlay_inputs[] = {
+     {
+         .name         = "main",
+         .type         = AVMEDIA_TYPE_VIDEO,
 -        .draw_slice   = null_draw_slice,
++        .get_video_buffer= get_video_buffer,
+         .config_props = config_input_main,
 -        .min_perms    = AV_PERM_READ,
 -        .rej_perms    = AV_PERM_REUSE2 | AV_PERM_PRESERVE,
 -        .needs_fifo   = 1,
++        .start_frame  = start_frame_main,
++        .draw_slice   = draw_slice_main,
+         .end_frame    = end_frame_main,
 -        .start_frame  = null_start_frame,
++        .min_perms    = AV_PERM_READ | AV_PERM_WRITE | AV_PERM_PRESERVE,
+     },
+     {
+         .name         = "overlay",
+         .type         = AVMEDIA_TYPE_VIDEO,
 -        .end_frame    = end_frame_overlay,
 -        .min_perms    = AV_PERM_READ,
 -        .rej_perms    = AV_PERM_REUSE2,
 -        .needs_fifo   = 1,
+         .config_props = config_input_overlay,
++        .start_frame  = start_frame_over,
+         .draw_slice   = null_draw_slice,
++        .end_frame    = end_frame_over,
++        .min_perms    = AV_PERM_READ | AV_PERM_PRESERVE,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_overlay_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_VIDEO,
++        .rej_perms     = AV_PERM_WRITE,
+         .config_props  = config_output,
+         .request_frame = request_frame,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_overlay = {
      .name      = "overlay",
      .description = NULL_IF_CONFIG_SMALL("Overlay a video source on top of the input."),
  
      .query_formats = query_formats,
  
-     .inputs    = (const AVFilterPad[]) {{ .name            = "main",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .get_video_buffer= get_video_buffer,
-                                           .config_props    = config_input_main,
-                                           .start_frame     = start_frame_main,
-                                           .draw_slice      = draw_slice_main,
-                                           .end_frame       = end_frame_main,
-                                           .min_perms       = AV_PERM_READ | AV_PERM_WRITE | AV_PERM_PRESERVE },
-                                         { .name            = "overlay",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .config_props    = config_input_overlay,
-                                           .start_frame     = start_frame_over,
-                                           .draw_slice      = null_draw_slice,
-                                           .end_frame       = end_frame_over,
-                                           .min_perms       = AV_PERM_READ | AV_PERM_PRESERVE },
-                                         { .name = NULL}},
-     .outputs   = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .rej_perms       = AV_PERM_WRITE,
-                                           .config_props    = config_output,
-                                           .request_frame   = request_frame, },
-                                         { .name = NULL}},
+     .inputs    = avfilter_vf_overlay_inputs,
+     .outputs   = avfilter_vf_overlay_outputs,
 +    .priv_class = &overlay_class,
  };
@@@ -388,24 -434,38 +388,36 @@@ static int draw_slice(AVFilterLink *lin
      return draw_send_bar_slice(link, y, h, slice_dir, -1);
  }
  
 -        .end_frame        = end_frame,
+ static const AVFilterPad avfilter_vf_pad_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .config_props     = config_input,
+         .get_video_buffer = get_video_buffer,
+         .start_frame      = start_frame,
+         .draw_slice       = draw_slice,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_pad_outputs[] = {
+     {
+         .name         = "default",
+         .type         = AVMEDIA_TYPE_VIDEO,
+         .config_props = config_output,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_pad = {
      .name          = "pad",
      .description   = NULL_IF_CONFIG_SMALL("Pad input image to width:height[:x:y[:color]] (default x and y: 0, default color: black)."),
  
      .priv_size     = sizeof(PadContext),
      .init          = init,
 -    .uninit        = uninit,
      .query_formats = query_formats,
  
-     .inputs    = (const AVFilterPad[]) {{ .name             = "default",
-                                           .type             = AVMEDIA_TYPE_VIDEO,
-                                           .config_props     = config_input,
-                                           .get_video_buffer = get_video_buffer,
-                                           .start_frame      = start_frame,
-                                           .draw_slice       = draw_slice, },
-                                         { .name = NULL}},
-     .outputs   = (const AVFilterPad[]) {{ .name             = "default",
-                                           .type             = AVMEDIA_TYPE_VIDEO,
-                                           .config_props     = config_output, },
-                                         { .name = NULL}},
+     .inputs    = avfilter_vf_pad_inputs,
+     .outputs   = avfilter_vf_pad_outputs,
  };
Simple merge
Simple merge
@@@ -391,32 -338,31 +391,56 @@@ static av_cold void uninit(AVFilterCont
          avfilter_unref_buffer(picref);
      av_fifo_free(select->pending_frames);
      select->pending_frames = NULL;
 +
 +    if (select->do_scene_detect) {
 +        avfilter_unref_bufferp(&select->prev_picref);
 +        if (select->avctx) {
 +            avcodec_close(select->avctx);
 +            av_freep(&select->avctx);
 +        }
 +    }
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    SelectContext *select = ctx->priv;
 +
 +    if (!select->do_scene_detect) {
 +        return ff_default_query_formats(ctx);
 +    } else {
 +        static const enum AVPixelFormat pix_fmts[] = {
 +            AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
 +            AV_PIX_FMT_NONE
 +        };
 +        ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 +    }
 +    return 0;
  }
  
+ static const AVFilterPad avfilter_vf_select_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .get_video_buffer = ff_null_get_video_buffer,
++        .min_perms        = AV_PERM_PRESERVE,
+         .config_props     = config_input,
+         .start_frame      = start_frame,
+         .draw_slice       = draw_slice,
+         .end_frame        = end_frame
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_select_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_VIDEO,
+         .poll_frame    = poll_frame,
+         .request_frame = request_frame,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_select = {
      .name      = "select",
      .description = NULL_IF_CONFIG_SMALL("Select frames to pass in output."),
Simple merge
Simple merge
@@@ -259,13 -208,26 +259,35 @@@ static int end_frame(AVFilterLink *inli
      return 0;
  }
  
 +static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
 +{
 +    TransContext *trans = inlink->dst->priv;
 +
 +    return trans->passthrough ? ff_null_draw_slice(inlink, y, h, slice_dir) : 0;
 +}
 +
+ static const AVFilterPad avfilter_vf_transpose_inputs[] = {
+     {
+         .name        = "default",
+         .type        = AVMEDIA_TYPE_VIDEO,
++        .get_video_buffer= get_video_buffer,
+         .start_frame = start_frame,
++        .draw_slice  = draw_slice,
+         .end_frame   = end_frame,
+         .min_perms   = AV_PERM_READ,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_transpose_outputs[] = {
+     {
+         .name         = "default",
+         .config_props = config_props_output,
+         .type         = AVMEDIA_TYPE_VIDEO,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_transpose = {
      .name      = "transpose",
      .description = NULL_IF_CONFIG_SMALL("Transpose input video."),
  
      .query_formats = query_formats,
  
-     .inputs    = (const AVFilterPad[]) {{ .name            = "default",
-                                           .type            = AVMEDIA_TYPE_VIDEO,
-                                           .get_video_buffer= get_video_buffer,
-                                           .start_frame     = start_frame,
-                                           .draw_slice      = draw_slice,
-                                           .end_frame       = end_frame,
-                                           .min_perms       = AV_PERM_READ, },
-                                         { .name = NULL}},
-     .outputs   = (const AVFilterPad[]) {{ .name            = "default",
-                                           .config_props    = config_props_output,
-                                           .type            = AVMEDIA_TYPE_VIDEO, },
-                                         { .name = NULL}},
+     .inputs    = avfilter_vf_transpose_inputs,
+     .outputs   = avfilter_vf_transpose_outputs,
 +    .priv_class = &transpose_class,
  };
Simple merge
Simple merge
@@@ -441,9 -424,32 +441,32 @@@ static int config_props(AVFilterLink *l
      return 0;
  }
  
 -        .get_video_buffer = get_video_buffer,
+ static const AVFilterPad avfilter_vf_yadif_inputs[] = {
+     {
+         .name             = "default",
+         .type             = AVMEDIA_TYPE_VIDEO,
+         .start_frame      = start_frame,
+         .draw_slice       = null_draw_slice,
+         .end_frame        = end_frame,
++        .min_perms        = AV_PERM_PRESERVE,
+     },
+     { NULL }
+ };
+ static const AVFilterPad avfilter_vf_yadif_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_VIDEO,
+         .poll_frame    = poll_frame,
+         .request_frame = request_frame,
+         .config_props  = config_props,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vf_yadif = {
      .name          = "yadif",
 -    .description   = NULL_IF_CONFIG_SMALL("Deinterlace the input image"),
 +    .description   = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
  
      .priv_size     = sizeof(YADIFContext),
      .init          = init,
Simple merge
@@@ -525,23 -359,27 +525,28 @@@ static int test_query_formats(AVFilterC
      return 0;
  }
  
+ static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_VIDEO,
+         .request_frame = request_frame,
+         .config_props  = config_props,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vsrc_testsrc = {
 -    .name          = "testsrc",
 -    .description   = NULL_IF_CONFIG_SMALL("Generate test pattern."),
 -    .priv_size     = sizeof(TestSourceContext),
 -    .init          = test_init,
 +    .name      = "testsrc",
 +    .description = NULL_IF_CONFIG_SMALL("Generate test pattern."),
 +    .priv_size = sizeof(TestSourceContext),
 +    .init      = test_init,
 +    .uninit    = uninit,
  
 -    .query_formats = test_query_formats,
 +    .query_formats   = test_query_formats,
  
      .inputs    = NULL,
--
-     .outputs   = (const AVFilterPad[]) {{ .name = "default",
-                                           .type = AVMEDIA_TYPE_VIDEO,
-                                           .request_frame = request_frame,
-                                           .config_props  = config_props, },
-                                         { .name = NULL }},
+     .outputs   = avfilter_vsrc_testsrc_outputs,
 +    .priv_class = &testsrc_class,
  };
  
  #endif /* CONFIG_TESTSRC_FILTER */
@@@ -639,23 -492,27 +644,29 @@@ static int rgbtest_config_props(AVFilte
      return config_props(outlink);
  }
  
+ static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {
+     {
+         .name          = "default",
+         .type          = AVMEDIA_TYPE_VIDEO,
+         .request_frame = request_frame,
+         .config_props  = rgbtest_config_props,
+     },
+     { NULL }
+ };
  AVFilter avfilter_vsrc_rgbtestsrc = {
 -    .name          = "rgbtestsrc",
 -    .description   = NULL_IF_CONFIG_SMALL("Generate RGB test pattern."),
 -    .priv_size     = sizeof(TestSourceContext),
 -    .init          = rgbtest_init,
 +    .name      = "rgbtestsrc",
 +    .description = NULL_IF_CONFIG_SMALL("Generate RGB test pattern."),
 +    .priv_size = sizeof(TestSourceContext),
 +    .init      = rgbtest_init,
 +    .uninit    = uninit,
  
 -    .query_formats = rgbtest_query_formats,
 +    .query_formats   = rgbtest_query_formats,
  
      .inputs    = NULL,
  
-     .outputs   = (const AVFilterPad[]) {{ .name = "default",
-                                           .type = AVMEDIA_TYPE_VIDEO,
-                                           .request_frame = request_frame,
-                                           .config_props  = rgbtest_config_props, },
-                                         { .name = NULL }},
+     .outputs   = avfilter_vsrc_rgbtestsrc_outputs,
 +    .priv_class = &rgbtestsrc_class,
  };
  
  #endif /* CONFIG_RGBTESTSRC_FILTER */
@@@ -951,8 -950,12 +951,11 @@@ static int mxf_get_sorted_table_segment
          if (mxf->metadata_sets[i]->type == IndexTableSegment)
              nb_segments++;
  
 -    *sorted_segments  = av_mallocz(nb_segments * sizeof(**sorted_segments));
 -    unsorted_segments = av_mallocz(nb_segments * sizeof(*unsorted_segments));
 -    if (!sorted_segments || !unsorted_segments) {
+     if (!nb_segments)
+         return AVERROR_INVALIDDATA;
 +    if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
 +        !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
          av_freep(sorted_segments);
          av_free(unsorted_segments);
          return AVERROR(ENOMEM);
diff --cc library.mak
@@@ -43,15 -43,11 +43,15 @@@ $(EXAMPLES) $(TESTPROGS) $(TOOLS): %$(E
  $(SUBDIR)$(SLIBNAME): $(SUBDIR)$(SLIBNAME_WITH_MAJOR)
        $(Q)cd ./$(SUBDIR) && $(LN_S) $(SLIBNAME_WITH_MAJOR) $(SLIBNAME)
  
 -$(SUBDIR)$(SLIBNAME_WITH_MAJOR): $(OBJS) $(SUBDIR)lib$(NAME).ver $(DEP_LIBS)
 +$(SUBDIR)$(SLIBNAME_WITH_MAJOR): $(OBJS) $(SUBDIR)lib$(NAME).ver
        $(SLIB_CREATE_DEF_CMD)
-       $$(LD) $(SHFLAGS) $(LDFLAGS) $$(LD_O) $$(filter %.o,$$^) $(FFEXTRALIBS) $(EXTRAOBJS)
+       $$(LD) $(SHFLAGS) $(LDFLAGS) $$(LD_O) $$(filter %.o,$$^) $(FFEXTRALIBS)
        $(SLIB_EXTRA_CMD)
  
 +ifdef SUBDIR
 +$(SUBDIR)$(SLIBNAME_WITH_MAJOR): $(DEP_LIBS)
 +endif
 +
  clean::
        $(RM) $(addprefix $(SUBDIR),*-example$(EXESUF) *-test$(EXESUF) $(CLEANFILES) $(CLEANSUFFIXES) $(LIBSUFFIXES)) \
            $(CLEANSUFFIXES:%=$(SUBDIR)$(ARCH)/%) $(HOSTOBJS) $(HOSTPROGS)
Simple merge
index 0000000,b7e8f49..d82c425
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,4 +1,4 @@@
 -8a7be9f9f97673bf8b926b6dcf8a710d *tests/data/fate/vsynth1-h263-obmc.avi
 -657366 tests/data/fate/vsynth1-h263-obmc.avi
 -eba1d733a0c4b71322a78f718f312599 *tests/data/fate/vsynth1-h263-obmc.out.rawvideo
++bdd8f9cafa39df97f2e395110f4419e0 *tests/data/fate/vsynth1-h263-obmc.avi
++657328 tests/data/fate/vsynth1-h263-obmc.avi
++844f7ee27fa122e199fe20987b41a15c *tests/data/fate/vsynth1-h263-obmc.out.rawvideo
+ stddev:    8.16 PSNR: 29.89 MAXDIFF:  113 bytes:  7603200/  7603200
index 0000000,32c2341..d8a65db
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,4 +1,4 @@@
 -0c84ee18c2261070ffc91b5d606094ae *tests/data/fate/vsynth2-h263-obmc.avi
 -154728 tests/data/fate/vsynth2-h263-obmc.avi
 -6f326547cf1cbd95a8c0a5ddce9eb71a *tests/data/fate/vsynth2-h263-obmc.out.rawvideo
++482d48074d94ed72b0c7057b9c129b45 *tests/data/fate/vsynth2-h263-obmc.avi
++154738 tests/data/fate/vsynth2-h263-obmc.avi
++588d992d9d8096da8bdc5027268da914 *tests/data/fate/vsynth2-h263-obmc.out.rawvideo
+ stddev:    5.39 PSNR: 33.49 MAXDIFF:   82 bytes:  7603200/  7603200