1 files changed, 377 insertions, 53 deletions

diff --git a/libavfilter/avfilter.c b/libavfilter/avfilter.c
index 59beb6d2b3..b301b33de2 100644
--- a/libavfilter/avfilter.c
+++ b/libavfilter/avfilter.c
@@ -2,25 +2,24 @@
  * filter layer
  * Copyright (c) 2007 Bobby Bingham
  *
- * This file is part of Libav.
+ * This file is part of FFmpeg.
  *
- * Libav is free software; you can redistribute it and/or
+ * 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.
  *
- * Libav is distributed in the hope that it will be useful,
+ * 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 Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-/* #define DEBUG */
-
+#include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
 #include "libavutil/channel_layout.h"
 #include "libavutil/common.h"
@@ -34,21 +33,61 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
-#include "video.h"
+#include "audio.h"
+
+static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame);
+
+void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
+{
+    av_unused char buf[16];
+    ff_tlog(ctx,
+            "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
+            ref, ref->buf, ref->data[0],
+            ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
+            ref->pts, av_frame_get_pkt_pos(ref));
+
+    if (ref->width) {
+        ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
+                ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,
+                ref->width, ref->height,
+                !ref->interlaced_frame     ? 'P' :         /* Progressive  */
+                ref->top_field_first ? 'T' : 'B',    /* Top / Bottom */
+                ref->key_frame,
+                av_get_picture_type_char(ref->pict_type));
+    }
+    if (ref->nb_samples) {
+        ff_tlog(ctx, " cl:%"PRId64"d n:%d r:%d",
+                ref->channel_layout,
+                ref->nb_samples,
+                ref->sample_rate);
+    }
+
+    ff_tlog(ctx, "]%s", end ? "\n" : "");
+}
 
 unsigned avfilter_version(void) {
+    av_assert0(LIBAVFILTER_VERSION_MICRO >= 100);
     return LIBAVFILTER_VERSION_INT;
 }
 
 const char *avfilter_configuration(void)
 {
-    return LIBAV_CONFIGURATION;
+    return FFMPEG_CONFIGURATION;
 }
 
 const char *avfilter_license(void)
 {
 #define LICENSE_PREFIX "libavfilter license: "
-    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
+    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
+}
+
+void ff_command_queue_pop(AVFilterContext *filter)
+{
+    AVFilterCommand *c= filter->command_queue;
+    av_freep(&c->arg);
+    av_freep(&c->command);
+    filter->command_queue= c->next;
+    av_free(c);
 }
 
 void ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
@@ -83,8 +122,9 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
 
     if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
         av_log(src, AV_LOG_ERROR,
-               "Media type mismatch between the '%s' filter output pad %d and the '%s' filter input pad %d\n",
-               src->name, srcpad, dst->name, dstpad);
+               "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
+               src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
+               dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
         return AVERROR(EINVAL);
     }
 
@@ -96,12 +136,32 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
     link->srcpad  = &src->output_pads[srcpad];
     link->dstpad  = &dst->input_pads[dstpad];
     link->type    = src->output_pads[srcpad].type;
-    assert(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
+    av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
     link->format  = -1;
 
     return 0;
 }
 
+void avfilter_link_free(AVFilterLink **link)
+{
+    if (!*link)
+        return;
+
+    av_frame_free(&(*link)->partial_buf);
+
+    av_freep(link);
+}
+
+int avfilter_link_get_channels(AVFilterLink *link)
+{
+    return link->channels;
+}
+
+void avfilter_link_set_closed(AVFilterLink *link, int closed)
+{
+    link->closed = closed;
+}
+
 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
                            unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
 {
@@ -129,6 +189,7 @@ int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
     if (link->out_formats)
         ff_formats_changeref(&link->out_formats,
                                    &filt->outputs[filt_dstpad_idx]->out_formats);
+
     if (link->out_samplerates)
         ff_formats_changeref(&link->out_samplerates,
                                    &filt->outputs[filt_dstpad_idx]->out_samplerates);
@@ -147,9 +208,13 @@ int avfilter_config_links(AVFilterContext *filter)
 
     for (i = 0; i < filter->nb_inputs; i ++) {
         AVFilterLink *link = filter->inputs[i];
+        AVFilterLink *inlink;
 
         if (!link) continue;
 
+        inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
+        link->current_pts = AV_NOPTS_VALUE;
+
         switch (link->init_state) {
         case AVLINK_INIT:
             continue;
@@ -177,26 +242,39 @@ int avfilter_config_links(AVFilterContext *filter)
                 return ret;
             }
 
-            if (link->time_base.num == 0 && link->time_base.den == 0)
-                link->time_base = link->src && link->src->nb_inputs ?
-                    link->src->inputs[0]->time_base : AV_TIME_BASE_Q;
+            switch (link->type) {
+            case AVMEDIA_TYPE_VIDEO:
+                if (!link->time_base.num && !link->time_base.den)
+                    link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
 
-            if (link->type == AVMEDIA_TYPE_VIDEO) {
                 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
-                    link->sample_aspect_ratio = link->src->nb_inputs ?
-                        link->src->inputs[0]->sample_aspect_ratio : (AVRational){1,1};
+                    link->sample_aspect_ratio = inlink ?
+                        inlink->sample_aspect_ratio : (AVRational){1,1};
 
-                if (link->src->nb_inputs) {
+                if (inlink && !link->frame_rate.num && !link->frame_rate.den)
+                    link->frame_rate = inlink->frame_rate;
+
+                if (inlink) {
                     if (!link->w)
-                        link->w = link->src->inputs[0]->w;
+                        link->w = inlink->w;
                     if (!link->h)
-                        link->h = link->src->inputs[0]->h;
+                        link->h = inlink->h;
                 } else if (!link->w || !link->h) {
                     av_log(link->src, AV_LOG_ERROR,
                            "Video source filters must set their output link's "
                            "width and height\n");
                     return AVERROR(EINVAL);
                 }
+                break;
+
+            case AVMEDIA_TYPE_AUDIO:
+                if (inlink) {
+                    if (!link->time_base.num && !link->time_base.den)
+                        link->time_base = inlink->time_base;
+                }
+
+                if (!link->time_base.num && !link->time_base.den)
+                    link->time_base = (AVRational) {1, link->sample_rate};
             }
 
             if ((config_link = link->dstpad->config_props))
@@ -214,11 +292,11 @@ int avfilter_config_links(AVFilterContext *filter)
     return 0;
 }
 
-void ff_dlog_link(void *ctx, AVFilterLink *link, int end)
+void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
 {
     if (link->type == AVMEDIA_TYPE_VIDEO) {
-        av_dlog(ctx,
-                "link[%p s:%dx%d fmt:%-16s %-16s->%-16s]%s",
+        ff_tlog(ctx,
+                "link[%p s:%dx%d fmt:%s %s->%s]%s",
                 link, link->w, link->h,
                 av_get_pix_fmt_name(link->format),
                 link->src ? link->src->filter->name : "",
@@ -228,9 +306,9 @@ void ff_dlog_link(void *ctx, AVFilterLink *link, int end)
         char buf[128];
         av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
 
-        av_dlog(ctx,
-                "link[%p r:%d cl:%s fmt:%-16s %-16s->%-16s]%s",
-                link, link->sample_rate, buf,
+        ff_tlog(ctx,
+                "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
+                link, (int)link->sample_rate, buf,
                 av_get_sample_fmt_name(link->format),
                 link->src ? link->src->filter->name : "",
                 link->dst ? link->dst->filter->name : "",
@@ -240,13 +318,33 @@ void ff_dlog_link(void *ctx, AVFilterLink *link, int end)
 
 int ff_request_frame(AVFilterLink *link)
 {
-    FF_DPRINTF_START(NULL, request_frame); ff_dlog_link(NULL, link, 1);
-
-    if (link->srcpad->request_frame)
-        return link->srcpad->request_frame(link);
-    else if (link->src->inputs[0])
-        return ff_request_frame(link->src->inputs[0]);
-    else return -1;
+    int ret = -1;
+    FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
+
+    if (link->closed)
+        return AVERROR_EOF;
+    av_assert0(!link->frame_requested);
+    link->frame_requested = 1;
+    while (link->frame_requested) {
+        if (link->srcpad->request_frame)
+            ret = link->srcpad->request_frame(link);
+        else if (link->src->inputs[0])
+            ret = ff_request_frame(link->src->inputs[0]);
+        if (ret == AVERROR_EOF && link->partial_buf) {
+            AVFrame *pbuf = link->partial_buf;
+            link->partial_buf = NULL;
+            ret = ff_filter_frame_framed(link, pbuf);
+        }
+        if (ret < 0) {
+            link->frame_requested = 0;
+            if (ret == AVERROR_EOF)
+                link->closed = 1;
+        } else {
+            av_assert0(!link->frame_requested ||
+                       link->flags & FF_LINK_FLAG_REQUEST_LOOP);
+        }
+    }
+    return ret;
 }
 
 int ff_poll_frame(AVFilterLink *link)
@@ -267,7 +365,28 @@ int ff_poll_frame(AVFilterLink *link)
     return min;
 }
 
-#define MAX_REGISTERED_AVFILTERS_NB 64
+void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
+{
+    if (pts == AV_NOPTS_VALUE)
+        return;
+    link->current_pts = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
+    /* TODO use duration */
+    if (link->graph && link->age_index >= 0)
+        ff_avfilter_graph_update_heap(link->graph, link);
+}
+
+int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
+{
+    if(!strcmp(cmd, "ping")){
+        av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
+        return 0;
+    }else if(filter->filter->process_command) {
+        return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
+    }
+    return AVERROR(ENOSYS);
+}
+
+#define MAX_REGISTERED_AVFILTERS_NB 256
 
 static AVFilter *registered_avfilters[MAX_REGISTERED_AVFILTERS_NB + 1];
 
@@ -286,8 +405,21 @@ AVFilter *avfilter_get_by_name(const char *name)
 
 int avfilter_register(AVFilter *filter)
 {
-    if (next_registered_avfilter_idx == MAX_REGISTERED_AVFILTERS_NB)
-        return -1;
+    int i;
+
+    if (next_registered_avfilter_idx == MAX_REGISTERED_AVFILTERS_NB) {
+        av_log(NULL, AV_LOG_ERROR,
+               "Maximum number of registered filters %d reached, "
+               "impossible to register filter with name '%s'\n",
+               MAX_REGISTERED_AVFILTERS_NB, filter->name);
+        return AVERROR(ENOMEM);
+    }
+
+    for(i=0; filter->inputs && filter->inputs[i].name; i++) {
+        const AVFilterPad *input = &filter->inputs[i];
+        av_assert0(     !input->filter_frame
+                    || (!input->start_frame && !input->end_frame));
+    }
 
     registered_avfilters[next_registered_avfilter_idx++] = filter;
     return 0;
@@ -315,18 +447,54 @@ static int pad_count(const AVFilterPad *pads)
     return count;
 }
 
-static const char *filter_name(void *p)
+static const char *default_filter_name(void *filter_ctx)
+{
+    AVFilterContext *ctx = filter_ctx;
+    return ctx->name ? ctx->name : ctx->filter->name;
+}
+
+static void *filter_child_next(void *obj, void *prev)
+{
+    AVFilterContext *ctx = obj;
+    if (!prev && ctx->filter && ctx->filter->priv_class)
+        return ctx->priv;
+    return NULL;
+}
+
+static const AVClass *filter_child_class_next(const AVClass *prev)
 {
-    AVFilterContext *filter = p;
-    return filter->filter->name;
+    AVFilter **filter_ptr = NULL;
+
+    /* find the filter that corresponds to prev */
+    while (prev && *(filter_ptr = av_filter_next(filter_ptr)))
+        if ((*filter_ptr)->priv_class == prev)
+            break;
+
+    /* could not find filter corresponding to prev */
+    if (prev && !(*filter_ptr))
+        return NULL;
+
+    /* find next filter with specific options */
+    while (*(filter_ptr = av_filter_next(filter_ptr)))
+        if ((*filter_ptr)->priv_class)
+            return (*filter_ptr)->priv_class;
+    return NULL;
 }
 
 static const AVClass avfilter_class = {
     .class_name = "AVFilter",
-    .item_name  = filter_name,
+    .item_name  = default_filter_name,
     .version    = LIBAVUTIL_VERSION_INT,
+    .category   = AV_CLASS_CATEGORY_FILTER,
+    .child_next = filter_child_next,
+    .child_class_next = filter_child_class_next,
 };
 
+const AVClass *avfilter_get_class(void)
+{
+    return &avfilter_class;
+}
+
 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
 {
     AVFilterContext *ret;
@@ -399,6 +567,9 @@ void avfilter_free(AVFilterContext *filter)
     int i;
     AVFilterLink *link;
 
+    if (!filter)
+        return;
+
     if (filter->filter->uninit)
         filter->filter->uninit(filter);
 
@@ -413,7 +584,7 @@ void avfilter_free(AVFilterContext *filter)
             ff_channel_layouts_unref(&link->in_channel_layouts);
             ff_channel_layouts_unref(&link->out_channel_layouts);
         }
-        av_freep(&link);
+        avfilter_link_free(&link);
     }
     for (i = 0; i < filter->nb_outputs; i++) {
         if ((link = filter->outputs[i])) {
@@ -426,10 +597,10 @@ void avfilter_free(AVFilterContext *filter)
             ff_channel_layouts_unref(&link->in_channel_layouts);
             ff_channel_layouts_unref(&link->out_channel_layouts);
         }
-        av_freep(&link);
+        avfilter_link_free(&link);
     }
 
-    if (filter->filter->priv_class)
+    if (filter->filter->priv_class || filter->filter->shorthand)
         av_opt_free(filter->priv);
 
     av_freep(&filter->name);
@@ -438,6 +609,9 @@ void avfilter_free(AVFilterContext *filter)
     av_freep(&filter->inputs);
     av_freep(&filter->outputs);
     av_freep(&filter->priv);
+    while(filter->command_queue){
+        ff_command_queue_pop(filter);
+    }
     av_free(filter);
 }
 
@@ -449,6 +623,7 @@ static int process_unnamed_options(AVFilterContext *ctx, AVDictionary **options,
     const AVOption *o = NULL;
     const char *p = args;
     char *val;
+    int offset= -1;
 
     while (*p) {
         o = av_opt_next(ctx->priv, o);
@@ -457,8 +632,9 @@ static int process_unnamed_options(AVFilterContext *ctx, AVDictionary **options,
                    "this filter supports.\n");
             return AVERROR(EINVAL);
         }
-        if (o->type == AV_OPT_TYPE_CONST)
+        if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
             continue;
+        offset = o->offset;
 
         val = av_get_token(&p, ":");
         if (!val)
@@ -479,8 +655,64 @@ int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque
     AVDictionary *options = NULL;
     AVDictionaryEntry *e;
     int ret=0;
+    int anton_options =
+        !strcmp(filter->filter->name,  "aformat") ||
+        !strcmp(filter->filter->name,  "ass")     ||
+        !strcmp(filter->filter->name,  "blackframe") ||
+        !strcmp(filter->filter->name,  "boxblur"   ) ||
+        !strcmp(filter->filter->name,  "colormatrix") ||
+        !strcmp(filter->filter->name,  "crop"      ) ||
+        !strcmp(filter->filter->name,  "cropdetect") ||
+        !strcmp(filter->filter->name,  "curves"    ) ||
+        !strcmp(filter->filter->name,  "delogo"    ) ||
+        !strcmp(filter->filter->name,  "drawbox"   ) ||
+        !strcmp(filter->filter->name,  "drawtext"  ) ||
+        !strcmp(filter->filter->name,  "ebur128"   ) ||
+        !strcmp(filter->filter->name,  "edgedetect") ||
+        !strcmp(filter->filter->name,  "fade"      ) ||
+        !strcmp(filter->filter->name,  "fieldorder") ||
+        !strcmp(filter->filter->name,  "fps"       ) ||
+        !strcmp(filter->filter->name,  "frei0r"    ) ||
+        !strcmp(filter->filter->name,  "frei0r_src") ||
+        !strcmp(filter->filter->name,  "geq"       ) ||
+        !strcmp(filter->filter->name, "gradfun"    ) ||
+        !strcmp(filter->filter->name, "hqdn3d"     ) ||
+        !strcmp(filter->filter->name, "ocv"        ) ||
+        !strcmp(filter->filter->name, "lut"        ) ||
+        !strcmp(filter->filter->name, "lutyuv"     ) ||
+        !strcmp(filter->filter->name, "lutrgb"     ) ||
+        !strcmp(filter->filter->name, "negate"     ) ||
+        !strcmp(filter->filter->name, "overlay"    ) ||
+        !strcmp(filter->filter->name, "pad"        ) ||
+        !strcmp(filter->filter->name,   "format") ||
+        !strcmp(filter->filter->name, "noformat") ||
+        !strcmp(filter->filter->name, "perms")  ||
+        !strcmp(filter->filter->name, "pp"   )  ||
+        !strcmp(filter->filter->name, "aperms") ||
+        !strcmp(filter->filter->name, "resample") ||
+        !strcmp(filter->filter->name, "setpts"       ) ||
+        !strcmp(filter->filter->name, "showspectrum") ||
+        !strcmp(filter->filter->name, "silencedetect") ||
+        !strcmp(filter->filter->name, "subtitles") ||
+        !strcmp(filter->filter->name, "thumbnail") ||
+//         !strcmp(filter->filter->name, "scale"      ) ||
+        !strcmp(filter->filter->name, "select") ||
+        0
+        ;
+
+    if (filter->filter->shorthand) {
+        av_assert0(filter->priv);
+        av_assert0(filter->filter->priv_class);
+        *(const AVClass **)filter->priv = filter->filter->priv_class;
+        av_opt_set_defaults(filter->priv);
+        ret = av_opt_set_from_string(filter->priv, args,
+                                     filter->filter->shorthand, "=", ":");
+        if (ret < 0)
+            return ret;
+        args = NULL;
+    }
 
-    if (args && *args && filter->filter->priv_class) {
+    if (anton_options && args && *args && filter->filter->priv_class) {
 #if FF_API_OLD_FILTER_OPTS
         if (!strcmp(filter->filter->name, "scale") &&
             strchr(args, ':') < strchr(args, '=')) {
@@ -569,7 +801,7 @@ int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque
         }
     }
 
-    if (filter->filter->priv_class) {
+    if (anton_options && filter->filter->priv_class) {
         ret = av_opt_set_dict(filter->priv, &options);
         if (ret < 0) {
             av_log(filter, AV_LOG_ERROR, "Error applying options to the filter.\n");
@@ -577,7 +809,9 @@ int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque
         }
     }
 
-    if (filter->filter->init)
+    if (filter->filter->init_opaque)
+        ret = filter->filter->init_opaque(filter, args, opaque);
+    else if (filter->filter->init)
         ret = filter->filter->init(filter, args);
     else if (filter->filter->init_dict)
         ret = filter->filter->init_dict(filter, &options);
@@ -611,14 +845,19 @@ static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
     return ff_filter_frame(link->dst->outputs[0], frame);
 }
 
-int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
+static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
 {
     int (*filter_frame)(AVFilterLink *, AVFrame *);
     AVFilterPad *dst = link->dstpad;
     AVFrame *out;
+    int ret;
+    AVFilterCommand *cmd= link->dst->command_queue;
+    int64_t pts;
 
-    FF_DPRINTF_START(NULL, filter_frame);
-    ff_dlog_link(NULL, link, 1);
+    if (link->closed) {
+        av_frame_free(&frame);
+        return AVERROR_EOF;
+    }
 
     if (!(filter_frame = dst->filter_frame))
         filter_frame = default_filter_frame;
@@ -627,6 +866,7 @@ int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
     if (dst->needs_writable && !av_frame_is_writable(frame)) {
         av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
 
+        /* Maybe use ff_copy_buffer_ref instead? */
         switch (link->type) {
         case AVMEDIA_TYPE_VIDEO:
             out = ff_get_video_buffer(link, link->w, link->h);
@@ -644,7 +884,7 @@ int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
 
         switch (link->type) {
         case AVMEDIA_TYPE_VIDEO:
-            av_image_copy(out->data, out->linesize, frame->data, frame->linesize,
+            av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
                           frame->format, frame->width, frame->height);
             break;
         case AVMEDIA_TYPE_AUDIO:
@@ -660,5 +900,89 @@ int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
     } else
         out = frame;
 
-    return filter_frame(link, out);
+    while(cmd && cmd->time <= out->pts * av_q2d(link->time_base)){
+        av_log(link->dst, AV_LOG_DEBUG,
+               "Processing command time:%f command:%s arg:%s\n",
+               cmd->time, cmd->command, cmd->arg);
+        avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
+        ff_command_queue_pop(link->dst);
+        cmd= link->dst->command_queue;
+    }
+
+    pts = out->pts;
+    ret = filter_frame(link, out);
+    link->frame_requested = 0;
+    ff_update_link_current_pts(link, pts);
+    return ret;
+}
+
+static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame)
+{
+    int insamples = frame->nb_samples, inpos = 0, nb_samples;
+    AVFrame *pbuf = link->partial_buf;
+    int nb_channels = av_frame_get_channels(frame);
+    int ret = 0;
+
+    link->flags |= FF_LINK_FLAG_REQUEST_LOOP;
+    /* Handle framing (min_samples, max_samples) */
+    while (insamples) {
+        if (!pbuf) {
+            AVRational samples_tb = { 1, link->sample_rate };
+            pbuf = ff_get_audio_buffer(link, link->partial_buf_size);
+            if (!pbuf) {
+                av_log(link->dst, AV_LOG_WARNING,
+                       "Samples dropped due to memory allocation failure.\n");
+                return 0;
+            }
+            av_frame_copy_props(pbuf, frame);
+            pbuf->pts = frame->pts +
+                        av_rescale_q(inpos, samples_tb, link->time_base);
+            pbuf->nb_samples = 0;
+        }
+        nb_samples = FFMIN(insamples,
+                           link->partial_buf_size - pbuf->nb_samples);
+        av_samples_copy(pbuf->extended_data, frame->extended_data,
+                        pbuf->nb_samples, inpos,
+                        nb_samples, nb_channels, link->format);
+        inpos                   += nb_samples;
+        insamples               -= nb_samples;
+        pbuf->nb_samples += nb_samples;
+        if (pbuf->nb_samples >= link->min_samples) {
+            ret = ff_filter_frame_framed(link, pbuf);
+            pbuf = NULL;
+        }
+    }
+    av_frame_free(&frame);
+    link->partial_buf = pbuf;
+    return ret;
+}
+
+int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
+{
+    FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
+
+    /* Consistency checks */
+    if (link->type == AVMEDIA_TYPE_VIDEO) {
+        if (strcmp(link->dst->filter->name, "scale")) {
+            av_assert1(frame->format                 == link->format);
+            av_assert1(frame->width               == link->w);
+            av_assert1(frame->height               == link->h);
+        }
+    } else {
+        av_assert1(frame->format                == link->format);
+        av_assert1(av_frame_get_channels(frame) == link->channels);
+        av_assert1(frame->channel_layout        == link->channel_layout);
+        av_assert1(frame->sample_rate           == link->sample_rate);
+    }
+
+    /* Go directly to actual filtering if possible */
+    if (link->type == AVMEDIA_TYPE_AUDIO &&
+        link->min_samples &&
+        (link->partial_buf ||
+         frame->nb_samples < link->min_samples ||
+         frame->nb_samples > link->max_samples)) {
+        return ff_filter_frame_needs_framing(link, frame);
+    } else {
+        return ff_filter_frame_framed(link, frame);
+    }
 }