/* #define DEBUG */
#include "avfilter.h"
+#include "formats.h"
#include "libavutil/eval.h"
#include "libavutil/avstring.h"
#include "libavutil/opt.h"
#include "libavutil/mathematics.h"
#include "libavutil/timestamp.h"
#include "internal.h"
+#include "bufferqueue.h"
#include "drawutils.h"
+#include "video.h"
static const char *const var_names[] = {
"main_w", "W", ///< width of the main video
int x, y; ///< position of overlayed picture
int allow_packed_rgb;
+ uint8_t frame_requested;
+ uint8_t overlay_eof;
uint8_t main_is_packed_rgb;
uint8_t main_rgba_map[4];
uint8_t main_has_alpha;
uint8_t overlay_rgba_map[4];
uint8_t overlay_has_alpha;
- AVFilterBufferRef *overpicref, *overpicref_next;
+ AVFilterBufferRef *overpicref;
+ struct FFBufQueue queue_main;
+ struct FFBufQueue queue_over;
int main_pix_step[4]; ///< steps per pixel for each plane of the main output
int overlay_pix_step[4]; ///< steps per pixel for each plane of the overlay
{NULL},
};
-static const char *overlay_get_name(void *ctx)
-{
- return "overlay";
-}
-
-static const AVClass overlay_class = {
- "OverlayContext",
- overlay_get_name,
- overlay_options
-};
+AVFILTER_DEFINE_CLASS(overlay);
-static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
+static av_cold int init(AVFilterContext *ctx, const char *args)
{
OverlayContext *over = ctx->priv;
char *args1 = av_strdup(args);
av_freep(&over->x_expr);
av_freep(&over->y_expr);
- if (over->overpicref)
- avfilter_unref_buffer(over->overpicref);
- if (over->overpicref_next)
- avfilter_unref_buffer(over->overpicref_next);
+ avfilter_unref_bufferp(&over->overpicref);
+ ff_bufqueue_discard_all(&over->queue_main);
+ ff_bufqueue_discard_all(&over->queue_over);
}
static int query_formats(AVFilterContext *ctx)
AVFilterFormats *overlay_formats;
if (over->allow_packed_rgb) {
- main_formats = avfilter_make_format_list(main_pix_fmts_rgb);
- overlay_formats = avfilter_make_format_list(overlay_pix_fmts_rgb);
+ main_formats = ff_make_format_list(main_pix_fmts_rgb);
+ overlay_formats = ff_make_format_list(overlay_pix_fmts_rgb);
} else {
- main_formats = avfilter_make_format_list(main_pix_fmts_yuv);
- overlay_formats = avfilter_make_format_list(overlay_pix_fmts_yuv);
+ main_formats = ff_make_format_list(main_pix_fmts_yuv);
+ overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv);
}
- avfilter_formats_ref(main_formats, &ctx->inputs [MAIN ]->out_formats);
- avfilter_formats_ref(overlay_formats, &ctx->inputs [OVERLAY]->out_formats);
- avfilter_formats_ref(main_formats, &ctx->outputs[MAIN ]->in_formats );
+ ff_formats_ref(main_formats, &ctx->inputs [MAIN ]->out_formats);
+ ff_formats_ref(overlay_formats, &ctx->inputs [OVERLAY]->out_formats);
+ ff_formats_ref(main_formats, &ctx->outputs[MAIN ]->in_formats );
return 0;
}
ff_fill_rgba_map(over->overlay_rgba_map, inlink->format) >= 0;
over->overlay_has_alpha = ff_fmt_is_in(inlink->format, alpha_pix_fmts);
- av_log(ctx, AV_LOG_INFO,
+ av_log(ctx, AV_LOG_VERBOSE,
"main w:%d h:%d fmt:%s overlay x:%d y:%d w:%d h:%d fmt:%s\n",
ctx->inputs[MAIN]->w, ctx->inputs[MAIN]->h,
av_pix_fmt_descriptors[ctx->inputs[MAIN]->format].name,
av_gcd((int64_t)tb1.num * tb2.den,
(int64_t)tb2.num * tb1.den),
(int64_t)tb1.den * tb2.den, INT_MAX);
- av_log(ctx, AV_LOG_INFO,
+ av_log(ctx, AV_LOG_VERBOSE,
"main_tb:%d/%d overlay_tb:%d/%d -> tb:%d/%d exact:%d\n",
tb1.num, tb1.den, tb2.num, tb2.den, tb->num, tb->den, exact);
if (!exact)
static AVFilterBufferRef *get_video_buffer(AVFilterLink *link, int perms, int w, int h)
{
- return avfilter_get_video_buffer(link->dst->outputs[0], perms, w, h);
-}
-
-static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
-{
- AVFilterBufferRef *outpicref = avfilter_ref_buffer(inpicref, ~0);
- AVFilterContext *ctx = inlink->dst;
- OverlayContext *over = ctx->priv;
- av_unused AVFilterLink *outlink = ctx->outputs[0];
-
- inlink->dst->outputs[0]->out_buf = outpicref;
- outpicref->pts = av_rescale_q(outpicref->pts, ctx->inputs[MAIN]->time_base,
- ctx->outputs[0]->time_base);
-
- if (!over->overpicref || over->overpicref->pts < outpicref->pts) {
- if (!over->overpicref_next)
- avfilter_request_frame(ctx->inputs[OVERLAY]);
-
- if (over->overpicref && over->overpicref_next &&
- over->overpicref_next->pts <= outpicref->pts) {
- avfilter_unref_buffer(over->overpicref);
- over->overpicref = over->overpicref_next;
- over->overpicref_next = NULL;
- }
- }
-
- av_dlog(ctx, "main_pts:%s main_pts_time:%s",
- av_ts2str(outpicref->pts), av_ts2timestr(outpicref->pts, &outlink->time_base));
- if (over->overpicref)
- av_dlog(ctx, " over_pts:%s over_pts_time:%s",
- av_ts2str(over->overpicref->pts), av_ts2timestr(over->overpicref->pts, &outlink->time_base));
- av_dlog(ctx, "\n");
-
- avfilter_start_frame(inlink->dst->outputs[0], outpicref);
-}
-
-static void start_frame_overlay(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
-{
- AVFilterContext *ctx = inlink->dst;
- OverlayContext *over = ctx->priv;
-
- inpicref->pts = av_rescale_q(inpicref->pts, ctx->inputs[OVERLAY]->time_base,
- ctx->outputs[0]->time_base);
-
- if (!over->overpicref) over->overpicref = inpicref;
- else over->overpicref_next = inpicref;
+ return ff_get_video_buffer(link->dst->outputs[0], perms, w, h);
}
// divide by 255 and round to nearest
}
}
-static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
+static int try_start_frame(AVFilterContext *ctx, AVFilterBufferRef *mainpic)
{
- AVFilterContext *ctx = inlink->dst;
+ OverlayContext *over = ctx->priv;
+ AVFilterLink *outlink = ctx->outputs[0];
+ AVFilterBufferRef *next_overpic, *outpicref;
+
+ /* Discard obsolete overlay frames: if there is a next frame with pts is
+ * before the main frame, we can drop the current overlay. */
+ while (1) {
+ next_overpic = ff_bufqueue_peek(&over->queue_over, 0);
+ if (!next_overpic || next_overpic->pts > mainpic->pts)
+ break;
+ ff_bufqueue_get(&over->queue_over);
+ avfilter_unref_buffer(over->overpicref);
+ over->overpicref = next_overpic;
+ }
+ /* If there is no next frame and no EOF and the overlay frame is before
+ * the main frame, we can not know yet if it will be superseded. */
+ if (!over->queue_over.available && !over->overlay_eof &&
+ (!over->overpicref || over->overpicref->pts < mainpic->pts))
+ return AVERROR(EAGAIN);
+ /* At this point, we know that the current overlay frame extends to the
+ * time of the main frame. */
+ outlink->out_buf = outpicref = avfilter_ref_buffer(mainpic, ~0);
+
+ av_dlog(ctx, "main_pts:%s main_pts_time:%s",
+ av_ts2str(outpicref->pts), av_ts2timestr(outpicref->pts, &outlink->time_base));
+ if (over->overpicref)
+ av_dlog(ctx, " over_pts:%s over_pts_time:%s",
+ av_ts2str(over->overpicref->pts), av_ts2timestr(over->overpicref->pts, &outlink->time_base));
+ av_dlog(ctx, "\n");
+
+ ff_start_frame(ctx->outputs[0], avfilter_ref_buffer(outpicref, ~0));
+ over->frame_requested = 0;
+ return 0;
+}
+
+static int try_start_next_frame(AVFilterContext *ctx)
+{
+ OverlayContext *over = ctx->priv;
+ AVFilterBufferRef *next_mainpic = ff_bufqueue_peek(&over->queue_main, 0);
+ if (!next_mainpic || try_start_frame(ctx, next_mainpic) < 0)
+ return AVERROR(EAGAIN);
+ avfilter_unref_buffer(ff_bufqueue_get(&over->queue_main));
+ return 0;
+}
+
+static int try_push_frame(AVFilterContext *ctx)
+{
+ OverlayContext *over = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
AVFilterBufferRef *outpicref = outlink->out_buf;
+
+ if (try_start_next_frame(ctx) < 0)
+ return AVERROR(EAGAIN);
+ outpicref = outlink->out_buf;
+ if (over->overpicref)
+ blend_slice(ctx, outpicref, over->overpicref, over->x, over->y,
+ over->overpicref->video->w, over->overpicref->video->h,
+ 0, outpicref->video->w, outpicref->video->h);
+ ff_draw_slice(outlink, 0, outpicref->video->h, +1);
+ ff_end_frame(outlink);
+ return 0;
+}
+
+static void flush_frames(AVFilterContext *ctx)
+{
+ while (!try_push_frame(ctx));
+}
+
+static int start_frame_main(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
+{
+ AVFilterContext *ctx = inlink->dst;
OverlayContext *over = ctx->priv;
+ flush_frames(ctx);
+ inpicref->pts = av_rescale_q(inpicref->pts, ctx->inputs[MAIN]->time_base,
+ ctx->outputs[0]->time_base);
+ if (try_start_frame(ctx, inpicref) < 0) {
+ ff_bufqueue_add(ctx, &over->queue_main, inpicref);
+ av_assert1(inpicref == inlink->cur_buf);
+ inlink->cur_buf = NULL;
+ }
+ return 0;
+}
+
+static int draw_slice_main(AVFilterLink *inlink, int y, int h, int slice_dir)
+{
+ AVFilterContext *ctx = inlink->dst;
+ OverlayContext *over = ctx->priv;
+ AVFilterLink *outlink = ctx->outputs[0];
+ AVFilterBufferRef *outpicref = outlink->out_buf;
+
+ if (!outpicref)
+ return 0;
if (over->overpicref &&
- !(over->x >= outpicref->video->w || over->y >= outpicref->video->h ||
- y+h < over->y || y >= over->y + over->overpicref->video->h)) {
+ 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);
}
- avfilter_draw_slice(outlink, y, h, slice_dir);
+ return ff_draw_slice(outlink, y, h, slice_dir);
}
-static void end_frame(AVFilterLink *inlink)
+static int end_frame_main(AVFilterLink *inlink)
{
- avfilter_end_frame(inlink->dst->outputs[0]);
- avfilter_unref_buffer(inlink->cur_buf);
-}
+ AVFilterContext *ctx = inlink->dst;
+ AVFilterLink *outlink = ctx->outputs[0];
+ AVFilterBufferRef *outpicref = outlink->out_buf;
+ flush_frames(ctx);
-static void null_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir) { }
+ if (!outpicref)
+ return 0;
+ return ff_end_frame(ctx->outputs[0]);
+}
-static void null_end_frame(AVFilterLink *inlink) { }
+static int start_frame_over(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
+{
+ return 0;
+}
-static int poll_frame(AVFilterLink *link)
+static int end_frame_over(AVFilterLink *inlink)
{
- AVFilterContext *s = link->src;
- OverlayContext *over = s->priv;
- int ret = avfilter_poll_frame(s->inputs[OVERLAY]);
+ AVFilterContext *ctx = inlink->dst;
+ OverlayContext *over = ctx->priv;
+ AVFilterBufferRef *inpicref = inlink->cur_buf;
+ inlink->cur_buf = NULL;
- if (ret == AVERROR_EOF)
- ret = !!over->overpicref;
+ flush_frames(ctx);
+ inpicref->pts = av_rescale_q(inpicref->pts, ctx->inputs[OVERLAY]->time_base,
+ ctx->outputs[0]->time_base);
+ ff_bufqueue_add(ctx, &over->queue_over, inpicref);
+ return try_push_frame(ctx);
+}
+
+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 (!try_start_next_frame(ctx))
+ return 0;
+ ret = 0; /* continue requesting frames on main */
+ }
+ if (ret < 0)
+ return ret;
+ }
+ return 0;
+}
- return ret && avfilter_poll_frame(s->inputs[MAIN]);
+static int null_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
+{
+ return 0;
}
AVFilter avfilter_vf_overlay = {
.query_formats = query_formats,
- .inputs = (const AVFilterPad[]) {{ .name = "main",
- .type = AVMEDIA_TYPE_VIDEO,
- .start_frame = start_frame,
- .get_video_buffer= get_video_buffer,
- .config_props = config_input_main,
- .draw_slice = draw_slice,
- .end_frame = end_frame,
- .min_perms = AV_PERM_READ,
- .rej_perms = AV_PERM_REUSE2|AV_PERM_PRESERVE, },
- { .name = "overlay",
- .type = AVMEDIA_TYPE_VIDEO,
- .start_frame = start_frame_overlay,
- .config_props = config_input_overlay,
- .draw_slice = null_draw_slice,
- .end_frame = null_end_frame,
- .min_perms = AV_PERM_READ,
- .rej_perms = AV_PERM_REUSE2, },
- { .name = NULL}},
- .outputs = (const AVFilterPad[]) {{ .name = "default",
- .type = AVMEDIA_TYPE_VIDEO,
- .config_props = config_output,
- .poll_frame = poll_frame },
- { .name = NULL}},
+ .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,
+ .rej_perms = AV_PERM_REUSE2|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,
+ .rej_perms = AV_PERM_REUSE2, },
+ { .name = NULL}},
+ .outputs = (const AVFilterPad[]) {{ .name = "default",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .config_props = config_output,
+ .request_frame = request_frame, },
+ { .name = NULL}},
};
projects / ffmpeg / blobdiff