From 43286028906adab67ec87bc15ff3010d0f6c2ff0 Mon Sep 17 00:00:00 2001 From: Clément Bœsch Date: Sat, 25 May 2013 16:25:46 +0200 Subject: lavfi: add dual input helpers. --- libavfilter/dualinput.c | 159 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 159 insertions(+) create mode 100644 libavfilter/dualinput.c (limited to 'libavfilter/dualinput.c') 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]); +} -- cgit v1.2.3