@@ -370,6 +370,7 @@ int cmdutils_read_file(const char *filename, char **bufptr, size_t *size);

 FILE *get_preset_file(char *filename, size_t filename_size,

                       const char *preset_name, int is_path, const char *codec_name);

+

 /**

  * Do all the necessary cleanup and abort.

  * This function is implemented in the avtools, not cmdutils.

@@ -224,6 +224,9 @@ codec-dependent.

 @var{filter_graph} is a description of the filter graph to apply to

 the stream. Use @code{-filters} to show all the available filters

 (including also sources and sinks).

+

+See also the @option{-filter_complex} option if you want to create filter graphs

+with multiple inputs and/or outputs.

 @item -pre[:@var{stream_specifier}] @var{preset_name} (@emph{output,per-stream})

 Specify the preset for matching stream(s).

@@ -522,7 +525,7 @@ Synchronize read on input.

 @section Advanced options

 @table @option

-@item -map [-]@var{input_file_id}[:@var{stream_specifier}][,@var{sync_file_id}[:@var{stream_specifier}]] (@emph{output})

+@item -map [-]@var{input_file_id}[:@var{stream_specifier}][,@var{sync_file_id}[:@var{stream_specifier}]] | @var{[linklabel]} (@emph{output})

 Designate one or more input streams as a source for the output file. Each input

 stream is identified by the input file index @var{input_file_id} and

@@ -538,6 +541,10 @@ the source for output stream 1, etc.

 A @code{-} character before the stream identifier creates a "negative" mapping.

 It disables matching streams from already created mappings.

+An alternative @var{[linklabel]} form will map outputs from complex filter

+graphs (see the @option{-filter_complex} option) to the output file.

+@var{linklabel} must correspond to a defined output link label in the graph.

+

 For example, to map ALL streams from the first input file to output

 @example

 ffmpeg -i INPUT -map 0 output

@@ -832,6 +839,44 @@ Specify Timecode for writing. @var{SEP} is ':' for non drop timecode and ';'

 @example

 ffmpeg -i input.mpg -timecode 01:02:03.04 -r 30000/1001 -s ntsc output.mpg

 @end example

+

+@item -filter_complex @var{filtergraph} (@emph{global})

+Define a complex filter graph, i.e. one with arbitrary number of inputs and/or

+outputs. For simple graphs -- those with one input and one output of the same

+type -- see the @option{-filter} options. @var{filtergraph} is a description of

+the filter graph, as described in @ref{Filtergraph syntax}.

+

+Input link labels must refer to input streams using the

+@code{[file_index:stream_specifier]} syntax (i.e. the same as @option{-map}

+uses). If @var{stream_specifier} matches multiple streams, the first one will be

+used. An unlabeled input will be connected to the first unused input stream of

+the matching type.

+

+Output link labels are referred to with @option{-map}. Unlabeled outputs are

+added to the first output file.

+

+For example, to overlay an image over video

+@example

+ffmpeg -i video.mkv -i image.png -filter_complex '[0:v][1:v]overlay[out]' -map

+'[out]' out.mkv

+@end example

+Here @code{[0:v]} refers to the first video stream in the first input file,

+which is linked to the first (main) input of the overlay filter. Similarly the

+first video stream in the second input is linked to the second (overlay) input

+of overlay.

+

+Assuming there is only one video stream in each input file, we can omit input

+labels, so the above is equivalent to

+@example

+ffmpeg -i video.mkv -i image.png -filter_complex 'overlay[out]' -map

+'[out]' out.mkv

+@end example

+

+Furthermore we can omit the output label and the single output from the filter

+graph will be added to the output file automatically, so we can simply write

+@example

+ffmpeg -i video.mkv -i image.png -filter_complex 'overlay' out.mkv

+@end example

 @end table

 @section Preset files

@@ -14,6 +14,7 @@ number of input and output pads of the filter.

 A filter with no input pads is called a "source", a filter with no

 output pads is called a "sink".

+@anchor{Filtergraph syntax}

 @section Filtergraph syntax

 A filtergraph can be represented using a textual representation, which

@@ -108,6 +108,7 @@ typedef struct StreamMap {

     int stream_index;

     int sync_file_index;

     int sync_stream_index;

+    char *linklabel;       /** name of an output link, for mapping lavfi outputs */

 } StreamMap;

 typedef struct {

@@ -175,6 +176,33 @@ static unsigned int allocated_async_buf_size;

 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"

+typedef struct InputFilter {

+    AVFilterContext    *filter;

+    struct InputStream *ist;

+    struct FilterGraph *graph;

+} InputFilter;

+

+typedef struct OutputFilter {

+    AVFilterContext     *filter;

+    struct OutputStream *ost;

+    struct FilterGraph  *graph;

+

+    /* temporary storage until stream maps are processed */

+    AVFilterInOut       *out_tmp;

+} OutputFilter;

+

+typedef struct FilterGraph {

+    int            index;

+    const char    *graph_desc;

+

+    AVFilterGraph *graph;

+

+    InputFilter   **inputs;

+    int          nb_inputs;

+    OutputFilter **outputs;

+    int         nb_outputs;

+} FilterGraph;

+

 typedef struct FrameBuffer {

     uint8_t *base[4];

     uint8_t *data[4];

@@ -195,7 +223,6 @@ typedef struct InputStream {

     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */

     AVCodec *dec;

     AVFrame *decoded_frame;

-    AVFrame *filtered_frame;

     int64_t       start;     /* time when read started */

     /* predicted dts of the next packet read for this stream or (when there are

@@ -211,9 +238,18 @@ typedef struct InputStream {

     int showed_multi_packet_warning;

     AVDictionary *opts;

+    int resample_height;

+    int resample_width;

+    int resample_pix_fmt;

+

     /* a pool of free buffers for decoded data */

     FrameBuffer *buffer_pool;

     int dr1;

+

+    /* decoded data from this stream goes into all those filters

+     * currently video only */

+    InputFilter **filters;

+    int        nb_filters;

 } InputStream;

 typedef struct InputFile {

@@ -242,17 +278,15 @@ typedef struct OutputStream {

     AVCodec *enc;

     int64_t max_frames;

     AVFrame *output_frame;

+    AVFrame *filtered_frame;

     /* video only */

-    int video_resample;

-    int resample_height;

-    int resample_width;

-    int resample_pix_fmt;

     AVRational frame_rate;

     int force_fps;

     int top_field_first;

     float frame_aspect_ratio;

+    float last_quality;

     /* forced key frames */

     int64_t *forced_kf_pts;

@@ -272,10 +306,8 @@ typedef struct OutputStream {

     SwrContext *swr;

-    AVFilterContext *output_video_filter;

-    AVFilterContext *input_video_filter;

+    OutputFilter *filter;

     char *avfilter;

-    AVFilterGraph *graph;

     int64_t sws_flags;

     int64_t swr_dither_method;

@@ -285,6 +317,8 @@ typedef struct OutputStream {

     int stream_copy;

     const char *attachment_filename;

     int copy_initial_nonkeyframes;

+

+    enum PixelFormat pix_fmts[2];

 } OutputStream;

@@ -304,15 +338,18 @@ typedef struct OutputFile {

     uint64_t limit_filesize; /* filesize limit expressed in bytes */

 } OutputFile;

-static InputStream *input_streams   = NULL;

-static int         nb_input_streams = 0;

-static InputFile   *input_files     = NULL;

-static int         nb_input_files   = 0;

+static InputStream **input_streams = NULL;

+static int        nb_input_streams = 0;

+static InputFile   **input_files   = NULL;

+static int        nb_input_files   = 0;

-static OutputStream *output_streams = NULL;

-static int        nb_output_streams = 0;

-static OutputFile   *output_files   = NULL;

-static int        nb_output_files   = 0;

+static OutputStream **output_streams = NULL;

+static int         nb_output_streams = 0;

+static OutputFile   **output_files   = NULL;

+static int         nb_output_files   = 0;

+

+static FilterGraph **filtergraphs;

+int               nb_filtergraphs;

 typedef struct OptionsContext {

     /* input/output options */

@@ -457,6 +494,7 @@ static 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) {

@@ -477,6 +515,8 @@ static void reset_options(OptionsContext *o, int is_input)

         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);

@@ -627,20 +667,64 @@ static void filter_release_buffer(AVFilterBuffer *fb)

     unref_buffer(buf->ist, buf);

 }

-static int configure_video_filters(InputStream *ist, OutputStream *ost)

+static void choose_pixel_fmt(AVStream *st, AVCodec *codec)

 {

+    if (codec && codec->pix_fmts) {

+        const enum PixelFormat *p = codec->pix_fmts;

+        int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;

+        enum PixelFormat best= PIX_FMT_NONE;

+        if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {

+            if (st->codec->codec_id == CODEC_ID_MJPEG) {

+                p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };

+            } else if (st->codec->codec_id == CODEC_ID_LJPEG) {

+                p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,

+                                                 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };

+            }

+        }

+        for (; *p != PIX_FMT_NONE; p++) {

+            best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);

+            if (*p == st->codec->pix_fmt)

+                break;

+        }

+        if (*p == PIX_FMT_NONE) {

+            if (st->codec->pix_fmt != PIX_FMT_NONE)

+                av_log(NULL, AV_LOG_WARNING,

+                       "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",

+                       av_pix_fmt_descriptors[st->codec->pix_fmt].name,

+                       codec->name,

+                       av_pix_fmt_descriptors[best].name);

+            st->codec->pix_fmt = best;

+        }

+    }

+}

+

+static const enum PixelFormat *choose_pixel_fmts(OutputStream *ost)

+{

+    if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {

+        ost->pix_fmts[0] = ost->st->codec->pix_fmt;

+        return ost->pix_fmts;

+    } else if (ost->enc->pix_fmts)

+        return ost->enc->pix_fmts;

+    else

+        return NULL;

+}

+

+static int configure_video_filters(FilterGraph *fg)

+{

+    InputStream  *ist = fg->inputs[0]->ist;

+    OutputStream *ost = fg->outputs[0]->ost;

     AVFilterContext *last_filter, *filter;

     /** filter graph containing all filters including input & output */

     AVCodecContext *codec = ost->st->codec;

-    AVCodecContext *icodec = ist->st->codec;

-    enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };

+    enum PixelFormat *pix_fmts = choose_pixel_fmts(ost);

     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();

     AVRational sample_aspect_ratio;

     char args[255];

     int ret;

-    ost->graph = avfilter_graph_alloc();

-    if (!ost->graph)

+    avfilter_graph_free(&fg->graph);

+    fg->graph = avfilter_graph_alloc();

+    if (!fg->graph)

         return AVERROR(ENOMEM);

     if (ist->st->sample_aspect_ratio.num) {

@@ -650,34 +734,35 @@ static int configure_video_filters(InputStream *ist, OutputStream *ost)

     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,

              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,

-             sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((icodec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));

+             sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));

-    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),

-                                       "src", args, NULL, ost->graph);

+    ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,

+                                       avfilter_get_by_name("buffer"),

+                                       "src", args, NULL, fg->graph);

     if (ret < 0)

         return ret;

 #if FF_API_OLD_VSINK_API

-    ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),

-                                       "out", NULL, pix_fmts, ost->graph);

+    ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),

+                                       "out", NULL, pix_fmts, fg->graph);

 #else

     buffersink_params->pixel_fmts = pix_fmts;

-    ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),

-                                       "out", NULL, buffersink_params, ost->graph);

+    ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),

+                                       "out", NULL, buffersink_params, fg->graph);

 #endif

     av_freep(&buffersink_params);

     if (ret < 0)

         return ret;

-    last_filter = ost->input_video_filter;

+    last_filter = fg->inputs[0]->filter;

-    if (codec->width != icodec->width || codec->height != icodec->height) {

+    if (codec->width || codec->height) {

         snprintf(args, 255, "%d:%d:flags=0x%X",

                  codec->width,

                  codec->height,

                  (unsigned)ost->sws_flags);

         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),

-                                                NULL, args, NULL, ost->graph)) < 0)

+                                                NULL, args, NULL, fg->graph)) < 0)

             return ret;

         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)

             return ret;

@@ -685,7 +770,7 @@ static int configure_video_filters(InputStream *ist, OutputStream *ost)

     }

     snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);

-    ost->graph->scale_sws_opts = av_strdup(args);

+    fg->graph->scale_sws_opts = av_strdup(args);

     if (ost->avfilter) {

         AVFilterInOut *outputs = avfilter_inout_alloc();

@@ -697,31 +782,258 @@ static int configure_video_filters(InputStream *ist, OutputStream *ost)

         outputs->next    = NULL;

         inputs->name    = av_strdup("out");

-        inputs->filter_ctx = ost->output_video_filter;

+        inputs->filter_ctx = fg->outputs[0]->filter;

         inputs->pad_idx = 0;

         inputs->next    = NULL;

-        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)

+        if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)

             return ret;

         av_freep(&ost->avfilter);

     } else {

-        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)

+        if ((ret = avfilter_link(last_filter, 0, fg->outputs[0]->filter, 0)) < 0)

             return ret;

     }

-    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)

+    if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)

         return ret;

-    codec->width  = ost->output_video_filter->inputs[0]->w;

-    codec->height = ost->output_video_filter->inputs[0]->h;

-    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =

-        ost->frame_aspect_ratio ? // overridden by the -aspect cli option

-        av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :

-        ost->output_video_filter->inputs[0]->sample_aspect_ratio;

+    ost->filter = fg->outputs[0];

     return 0;

 }

+static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)

+{

+    FilterGraph *fg = av_mallocz(sizeof(*fg));

+

+    if (!fg)

+        exit_program(1);

+    fg->index = nb_filtergraphs;

+

+    fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,

+                             fg->nb_outputs + 1);

+    if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))

+        exit_program(1);

+    fg->outputs[0]->ost   = ost;

+    fg->outputs[0]->graph = fg;

+

+    fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,

+                            fg->nb_inputs + 1);

+    if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))

+        exit_program(1);

+    fg->inputs[0]->ist   = ist;

+    fg->inputs[0]->graph = fg;

+

+    ist->filters = grow_array(ist->filters, sizeof(*ist->filters),

+                              &ist->nb_filters, ist->nb_filters + 1);

+    ist->filters[ist->nb_filters - 1] = fg->inputs[0];

+

+    filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),

+                              &nb_filtergraphs, nb_filtergraphs + 1);

+    filtergraphs[nb_filtergraphs - 1] = fg;

+

+    return fg;

+}

+

+static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)

+{

+    InputStream *ist;

+    enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;

+    int i;

+

+    // TODO: support other filter types

+    if (type != AVMEDIA_TYPE_VIDEO) {

+        av_log(NULL, AV_LOG_FATAL, "Only video filters supported currently.\n");

+        exit_program(1);

+    }

+

+    if (in->name) {

+        AVFormatContext *s;

+        AVStream       *st = NULL;

+        char *p;

+        int file_idx = strtol(in->name, &p, 0);

+

+        if (file_idx < 0 || file_idx > nb_input_files) {

+            av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtegraph description %s.\n",

+                   file_idx, fg->graph_desc);

+            exit_program(1);

+        }

+        s = input_files[file_idx]->ctx;

+

+        for (i = 0; i < s->nb_streams; i++) {

+            if (s->streams[i]->codec->codec_type != type)

+                continue;

+            if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {

+                st = s->streams[i];

+                break;

+            }

+        }

+        if (!st) {

+            av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "

+                   "matches no streams.\n", p, fg->graph_desc);

+            exit_program(1);

+        }

+        ist = input_streams[input_files[file_idx]->ist_index + st->index];

+    } else {

+        /* find the first unused stream of corresponding type */

+        for (i = 0; i < nb_input_streams; i++) {

+            ist = input_streams[i];

+            if (ist->st->codec->codec_type == type && ist->discard)

+                break;

+        }

+        if (i == nb_input_streams) {

+            av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "

+                   "unlabeled input pad %d on filter %s", in->pad_idx,

+                   in->filter_ctx->name);

+            exit_program(1);

+        }

+    }

+    ist->discard         = 0;

+    ist->decoding_needed = 1;

+    ist->st->discard = AVDISCARD_NONE;

+

+    fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),

+                            &fg->nb_inputs, fg->nb_inputs + 1);

+    if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))

+        exit_program(1);

+    fg->inputs[fg->nb_inputs - 1]->ist   = ist;

+    fg->inputs[fg->nb_inputs - 1]->graph = fg;

+

+    ist->filters = grow_array(ist->filters, sizeof(*ist->filters),

+                              &ist->nb_filters, ist->nb_filters + 1);

+    ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];

+}

+

+static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)

+{

+    AVCodecContext *codec = ofilter->ost->st->codec;

+    AVFilterContext *last_filter = out->filter_ctx;

+    int pad_idx = out->pad_idx;

+    int ret;

+    enum PixelFormat *pix_fmts = choose_pixel_fmts(ofilter->ost);

+    AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();

+

+#if FF_API_OLD_VSINK_API

+    ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),

+                                       "out", NULL, pix_fmts, fg->graph);

+#else

+    buffersink_params->pixel_fmts = pix_fmts;

+    ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),

+                                       "out", NULL, buffersink_params, fg->graph);

+#endif

+    av_freep(&buffersink_params);

+

+    if (ret < 0)

+        return ret;

+

+    if (codec->width || codec->height) {

+        char args[255];

+        snprintf(args, sizeof(args), "%d:%d:flags=0x%X",

+                 codec->width,

+                 codec->height,

+                 (unsigned)ofilter->ost->sws_flags);

+        if ((ret = avfilter_graph_create_filter(&last_filter, avfilter_get_by_name("scale"),

+                                                NULL, args, NULL, fg->graph)) < 0)

+            return ret;

+        if ((ret = avfilter_link(out->filter_ctx, out->pad_idx, last_filter, 0)) < 0)

+            return ret;

+        pad_idx = 0;

+    }

+

+    if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)

+        return ret;

+

+    return 0;

+}

+

+static int configure_complex_filter(FilterGraph *fg)

+{

+    AVFilterInOut *inputs, *outputs, *cur;

+    int ret, i, init = !fg->graph;

+

+    avfilter_graph_free(&fg->graph);

+    if (!(fg->graph = avfilter_graph_alloc()))

+        return AVERROR(ENOMEM);

+

+    if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)

+        return ret;

+

+    for (cur = inputs; init && cur; cur = cur->next)

+        init_input_filter(fg, cur);

+

+    for (cur = inputs, i = 0; cur; cur = cur->next, i++) {

+        InputFilter *ifilter = fg->inputs[i];

+        InputStream     *ist = ifilter->ist;

+        AVRational       sar;

+        char            args[255];

+

+        sar = ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :

+                                                 ist->st->codec->sample_aspect_ratio;

+        snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,

+                 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,

+                 sar.num, sar.den);

+

+        if ((ret = avfilter_graph_create_filter(&ifilter->filter,

+                                                avfilter_get_by_name("buffer"), cur->name,

+                                                args, NULL, fg->graph)) < 0)

+            return ret;

+        if ((ret = avfilter_link(ifilter->filter, 0,

+                                 cur->filter_ctx, cur->pad_idx)) < 0)

+            return ret;

+    }

+    avfilter_inout_free(&inputs);

+

+    if (!init) {

+        /* we already know the mappings between lavfi outputs and output streams,

+         * so we can finish the setup */

+        for (cur = outputs, i = 0; cur; cur = cur->next, i++)

+            configure_output_filter(fg, fg->outputs[i], cur);

+        avfilter_inout_free(&outputs);

+

+        if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)

+            return ret;

+    } else {

+        /* wait until output mappings are processed */

+        for (cur = outputs; cur;) {

+            fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),

+                                     &fg->nb_outputs, fg->nb_outputs + 1);

+            if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))

+                exit_program(1);

+            fg->outputs[fg->nb_outputs - 1]->graph   = fg;

+            fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;

+            cur = cur->next;

+            fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;

+        }

+    }

+

+    return 0;

+}

+

+static int configure_complex_filters(void)

+{

+    int i, ret = 0;

+

+    for (i = 0; i < nb_filtergraphs; i++)

+        if (!filtergraphs[i]->graph &&

+            (ret = configure_complex_filter(filtergraphs[i])) < 0)

+            return ret;

+    return 0;

+}

+

+static int configure_filtergraph(FilterGraph *fg)

+{

+    return fg->graph_desc ? configure_complex_filter(fg) : configure_video_filters(fg);

+}

+

+static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)

+{

+    int i;

+    for (i = 0; i < fg->nb_inputs; i++)

+        if (fg->inputs[i]->ist == ist)

+            return 1;

+    return 0;

+}

+

 static void term_exit(void)

 {

     av_log(NULL, AV_LOG_QUIET, "%s", "");

@@ -839,40 +1151,57 @@ static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };

 void av_noreturn exit_program(int ret)

 {

-    int i;

+    int i, j;

+

+    for (i = 0; i < nb_filtergraphs; i++) {

+        avfilter_graph_free(&filtergraphs[i]->graph);

+        for (j = 0; j < filtergraphs[i]->nb_inputs; j++)

+            av_freep(&filtergraphs[i]->inputs[j]);

+        av_freep(&filtergraphs[i]->inputs);

+        for (j = 0; j < filtergraphs[i]->nb_outputs; j++)

+            av_freep(&filtergraphs[i]->outputs[j]);

+        av_freep(&filtergraphs[i]->outputs);

+        av_freep(&filtergraphs[i]);

+    }

+    av_freep(&filtergraphs);

     /* close files */

     for (i = 0; i < nb_output_files; i++) {

-        AVFormatContext *s = output_files[i].ctx;

+        AVFormatContext *s = output_files[i]->ctx;

         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)

             avio_close(s->pb);

         avformat_free_context(s);

-        av_dict_free(&output_files[i].opts);

+        av_dict_free(&output_files[i]->opts);

+        av_freep(&output_files[i]);

     }

     for (i = 0; i < nb_output_streams; i++) {

-        AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;

+        AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;

         while (bsfc) {

             AVBitStreamFilterContext *next = bsfc->next;

             av_bitstream_filter_close(bsfc);

             bsfc = next;

         }

-        output_streams[i].bitstream_filters = NULL;

+        output_streams[i]->bitstream_filters = NULL;

-        if (output_streams[i].output_frame) {

-            AVFrame *frame = output_streams[i].output_frame;

+        if (output_streams[i]->output_frame) {

+            AVFrame *frame = output_streams[i]->output_frame;

             if (frame->extended_data != frame->data)

                 av_freep(&frame->extended_data);

             av_freep(&frame);

         }

+        av_freep(&output_streams[i]->filtered_frame);

+        av_freep(&output_streams[i]);

     }

     for (i = 0; i < nb_input_files; i++) {

-        avformat_close_input(&input_files[i].ctx);

+        avformat_close_input(&input_files[i]->ctx);

+        av_freep(&input_files[i]);

     }

     for (i = 0; i < nb_input_streams; i++) {

-        av_freep(&input_streams[i].decoded_frame);

-        av_freep(&input_streams[i].filtered_frame);

-        av_dict_free(&input_streams[i].opts);

-        free_buffer_pool(&input_streams[i]);

+        av_freep(&input_streams[i]->decoded_frame);

+        av_dict_free(&input_streams[i]->opts);

+        free_buffer_pool(input_streams[i]);

+        av_freep(&input_streams[i]->filters);

+        av_freep(&input_streams[i]);

     }

     if (vstats_file)

@@ -981,41 +1310,10 @@ static void choose_sample_rate(AVStream *st, AVCodec *codec)

     }

 }

-static void choose_pixel_fmt(AVStream *st, AVCodec *codec)

-{

-    if (codec && codec->pix_fmts) {

-        const enum PixelFormat *p = codec->pix_fmts;

-        int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;

-        enum PixelFormat best= PIX_FMT_NONE;

-        if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {

-            if (st->codec->codec_id == CODEC_ID_MJPEG) {

-                p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };

-            } else if (st->codec->codec_id == CODEC_ID_LJPEG) {

-                p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,

-                                                 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };

-            }

-        }

-        for (; *p != PIX_FMT_NONE; p++) {

-            best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);

-            if (*p == st->codec->pix_fmt)

-                break;

-        }

-        if (*p == PIX_FMT_NONE) {

-            if (st->codec->pix_fmt != PIX_FMT_NONE)

-                av_log(NULL, AV_LOG_WARNING,

-                       "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",

-                       av_pix_fmt_descriptors[st->codec->pix_fmt].name,

-                       codec->name,

-                       av_pix_fmt_descriptors[best].name);

-            st->codec->pix_fmt = best;

-        }

-    }

-}

-

 static double

 get_sync_ipts(const OutputStream *ost, int64_t pts)

 {

-    OutputFile *of = &output_files[ost->file_index];

+    OutputFile *of = output_files[ost->file_index];

     return (double)(pts - of->start_time) / AV_TIME_BASE;

 }

@@ -1518,19 +1816,21 @@ static void do_video_stats(AVFormatContext *os, OutputStream *ost,

 static void do_video_out(AVFormatContext *s, OutputStream *ost,

-                         InputStream *ist, AVFrame *in_picture)

+                         AVFrame *in_picture, float quality)

 {

     int nb_frames, i, ret, format_video_sync;

     AVCodecContext *enc;

     double sync_ipts, delta;

     double duration = 0;

     int frame_size = 0;

-    float quality = same_quant ? in_picture->quality

-                               : ost->st->codec->global_quality;

+    InputStream *ist = NULL;

+

+    if (ost->source_index >= 0)

+        ist = input_streams[ost->source_index];

     enc = ost->st->codec;

-    if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {

+    if (ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {

         duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));

         if(ist->st->r_frame_rate.num)

             duration= FFMAX(duration, 1/av_q2d(ist->st->r_frame_rate));

@@ -1672,12 +1972,66 @@ static void do_video_out(AVFormatContext *s, OutputStream *ost,

         ost->frame_number++;

     }

     if (vstats_filename && frame_size)

-        do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);

+        do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);

 }

-static void print_report(OutputFile *output_files,

-                         OutputStream *ost_table, int nb_ostreams,

-                         int is_last_report, int64_t timer_start, int64_t cur_time)

+/* check for new output on any of the filtergraphs */

+static int poll_filters(void)

+{

+    AVFilterBufferRef *picref;

+    AVFrame *filtered_frame = NULL;

+    int i, ret;

+

+    for (i = 0; i < nb_output_streams; i++) {

+        OutputStream *ost = output_streams[i];

+        OutputFile    *of = output_files[ost->file_index];

+

+        if (!ost->filter || ost->is_past_recording_time)

+            continue;

+

+        if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {

+            return AVERROR(ENOMEM);

+        } else

+            avcodec_get_frame_defaults(ost->filtered_frame);

+        filtered_frame = ost->filtered_frame;

+

+        while (avfilter_poll_frame(ost->filter->filter->inputs[0])) {

+            AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;

+            if ((ret = av_buffersink_get_buffer_ref(ost->filter->filter,

+                                                            &picref,

+                                                            0)) < 0) {

+                av_log(NULL, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");

+                return ret;

+            }

+            filtered_frame->pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);

+//             if (ost->source_index >= 0)

+//                 *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold

+

+            if (of->start_time && filtered_frame->pts < of->start_time)

+                return 0;

+

+            switch (ost->filter->filter->inputs[0]->type) {

+            case AVMEDIA_TYPE_VIDEO:

+                avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);

+                if (!ost->frame_aspect_ratio)

+                    ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;

+

+                do_video_out(of->ctx, ost, filtered_frame,

+                             same_quant ? ost->last_quality :

+                                          ost->st->codec->global_quality);

+                break;

+            default:

+                // TODO support audio/subtitle filters

+                av_assert0(0);

+            }

+

+            avfilter_unref_buffer(picref);

+        }

+    }

+    return 0;

+}

+

+static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)

 {

     char buf[1024];

     OutputStream *ost;

@@ -1705,7 +2059,7 @@ static void print_report(OutputFile *output_files,

     }

-    oc = output_files[0].ctx;

+    oc = output_files[0]->ctx;

     total_size = avio_size(oc->pb);

     if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too

@@ -1716,9 +2070,9 @@ static void print_report(OutputFile *output_files,

     buf[0] = '\0';

     vid = 0;

-    for (i = 0; i < nb_ostreams; i++) {

+    for (i = 0; i < nb_output_streams; i++) {

         float q = -1;

-        ost = &ost_table[i];

+        ost = output_streams[i];

         enc = ost->st->codec;

         if (!ost->stream_copy && enc->coded_frame)

             q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;

@@ -1811,14 +2165,14 @@ static void print_report(OutputFile *output_files,

     }

 }

-static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

+static void flush_encoders(void)

 {

     int i, ret;

-    for (i = 0; i < nb_ostreams; i++) {

-        OutputStream   *ost = &ost_table[i];

+    for (i = 0; i < nb_output_streams; i++) {

+        OutputStream   *ost = output_streams[i];

         AVCodecContext *enc = ost->st->codec;