lavfi: add dual input helpers.

1 files changed, 159 insertions, 0 deletions

diff --git a/libavfilter/dualinput.c b/libavfilter/dualinput.c
new file mode 100644
index 0000000000..10e365267b
--- /dev/null
+++ b/libavfilter/dualinput.c
@@ -0,0 +1,159 @@
+/*
+ * 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
+ */
+
+#define MAIN  0
+#define SECOND 1
+
+#include "dualinput.h"
+#include "libavutil/timestamp.h"
+
+static int try_filter_frame(FFDualInputContext *s,
+                            AVFilterContext *ctx, AVFrame *mainpic)
+{
+    int ret;
+
+    /* Discard obsolete second frames: if there is a next second frame with pts
+     * before the main frame, we can drop the current second. */
+    while (1) {
+        AVFrame *next_overpic = ff_bufqueue_peek(&s->queue[SECOND], 0);
+        if (!next_overpic && s->second_eof && !s->repeatlast) {
+            av_frame_free(&s->second_frame);
+            break;
+        }
+        if (!next_overpic || av_compare_ts(next_overpic->pts, ctx->inputs[SECOND]->time_base,
+                                           mainpic->pts,      ctx->inputs[MAIN]->time_base) > 0)
+            break;
+        ff_bufqueue_get(&s->queue[SECOND]);
+        av_frame_free(&s->second_frame);
+        s->second_frame = next_overpic;
+    }
+
+    /* If there is no next frame and no EOF and the second frame is before
+     * the main frame, we can not know yet if it will be superseded. */
+    if (!s->queue[SECOND].available && !s->second_eof &&
+        (!s->second_frame || av_compare_ts(s->second_frame->pts, ctx->inputs[SECOND]->time_base,
+                                           mainpic->pts,         ctx->inputs[MAIN]->time_base) < 0))
+        return AVERROR(EAGAIN);
+
+    /* At this point, we know that the current second frame extends to the
+     * time of the main frame. */
+    av_dlog(ctx, "main_pts:%s main_pts_time:%s",
+            av_ts2str(mainpic->pts), av_ts2timestr(mainpic->pts, &ctx->inputs[MAIN]->time_base));
+    if (s->second_frame)
+        av_dlog(ctx, " second_pts:%s second_pts_time:%s",
+                av_ts2str(s->second_frame->pts), av_ts2timestr(s->second_frame->pts, &ctx->inputs[SECOND]->time_base));
+    av_dlog(ctx, "\n");
+
+    if (s->second_frame && !ctx->is_disabled)
+        mainpic = s->process(ctx, mainpic, s->second_frame);
+    ret = ff_filter_frame(ctx->outputs[0], mainpic);
+    av_assert1(ret != AVERROR(EAGAIN));
+    s->frame_requested = 0;
+    return ret;
+}
+
+static int try_filter_next_frame(FFDualInputContext *s, AVFilterContext *ctx)
+{
+    AVFrame *next_mainpic = ff_bufqueue_peek(&s->queue[MAIN], 0);
+    int ret;
+
+    if (!next_mainpic)
+        return AVERROR(EAGAIN);
+    if ((ret = try_filter_frame(s, ctx, next_mainpic)) == AVERROR(EAGAIN))
+        return ret;
+    ff_bufqueue_get(&s->queue[MAIN]);
+    return ret;
+}
+
+static int flush_frames(FFDualInputContext *s, AVFilterContext *ctx)
+{
+    int ret;
+
+    while (!(ret = try_filter_next_frame(s, ctx)));
+    return ret == AVERROR(EAGAIN) ? 0 : ret;
+}
+
+int ff_dualinput_filter_frame_main(FFDualInputContext *s,
+                                   AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    int ret;
+
+    if ((ret = flush_frames(s, ctx)) < 0)
+        return ret;
+    if ((ret = try_filter_frame(s, ctx, in)) < 0) {
+        if (ret != AVERROR(EAGAIN))
+            return ret;
+        ff_bufqueue_add(ctx, &s->queue[MAIN], in);
+    }
+
+    if (!s->second_frame)
+        return 0;
+    flush_frames(s, ctx);
+
+    return 0;
+}
+
+int ff_dualinput_filter_frame_second(FFDualInputContext *s,
+                                     AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    int ret;
+
+    if ((ret = flush_frames(s, ctx)) < 0)
+        return ret;
+    ff_bufqueue_add(ctx, &s->queue[SECOND], in);
+    ret = try_filter_next_frame(s, ctx);
+    return ret == AVERROR(EAGAIN) ? 0 : ret;
+}
+
+int ff_dualinput_request_frame(FFDualInputContext *s, AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    int input, ret;
+
+    if (!try_filter_next_frame(s, ctx))
+        return 0;
+    s->frame_requested = 1;
+    while (s->frame_requested) {
+        /* TODO if we had a frame duration, we could guess more accurately */
+        input = !s->second_eof && (s->queue[MAIN].available ||
+                                   s->queue[SECOND].available < 2) ?
+                SECOND : MAIN;
+        ret = ff_request_frame(ctx->inputs[input]);
+        /* EOF on main is reported immediately */
+        if (ret == AVERROR_EOF && input == SECOND) {
+            s->second_eof = 1;
+            if (s->shortest)
+                return ret;
+            if ((ret = try_filter_next_frame(s, ctx)) != AVERROR(EAGAIN))
+                return ret;
+            ret = 0; /* continue requesting frames on main */
+        }
+        if (ret < 0)
+            return ret;
+    }
+    return 0;
+}
+
+void ff_dualinput_uninit(FFDualInputContext *s)
+{
+    av_frame_free(&s->second_frame);
+    ff_bufqueue_discard_all(&s->queue[MAIN]);
+    ff_bufqueue_discard_all(&s->queue[SECOND]);
+}