#include <string.h>
#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
#include "libavutil/pixfmt.h"
#include "avfilter.h"
-#include "bufferqueue.h"
#include "drawutils.h"
#include "formats.h"
+#include "filters.h"
#include "internal.h"
#include "video.h"
enum { Y, U, V, A };
typedef struct AlphaMergeContext {
+ const AVClass *class;
+
int is_packed_rgb;
uint8_t rgba_map[4];
- struct FFBufQueue queue_main;
- struct FFBufQueue queue_alpha;
+ AVFrame *main_frame;
+ AVFrame *alpha_frame;
} AlphaMergeContext;
-static av_cold void uninit(AVFilterContext *ctx)
-{
- AlphaMergeContext *merge = ctx->priv;
- ff_bufqueue_discard_all(&merge->queue_main);
- ff_bufqueue_discard_all(&merge->queue_alpha);
-}
-
static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat main_fmts[] = {
static int config_input_main(AVFilterLink *inlink)
{
- AlphaMergeContext *merge = inlink->dst->priv;
- merge->is_packed_rgb =
- ff_fill_rgba_map(merge->rgba_map, inlink->format) >= 0 &&
+ AlphaMergeContext *s = inlink->dst->priv;
+ s->is_packed_rgb =
+ ff_fill_rgba_map(s->rgba_map, inlink->format) >= 0 &&
inlink->format != AV_PIX_FMT_GBRAP;
return 0;
}
AVFrame *main_buf,
AVFrame *alpha_buf)
{
- AlphaMergeContext *merge = ctx->priv;
+ AlphaMergeContext *s = ctx->priv;
int h = main_buf->height;
- if (merge->is_packed_rgb) {
+ if (s->is_packed_rgb) {
int x, y;
uint8_t *pin, *pout;
for (y = 0; y < h; y++) {
pin = alpha_buf->data[0] + y * alpha_buf->linesize[0];
- pout = main_buf->data[0] + y * main_buf->linesize[0] + merge->rgba_map[A];
+ pout = main_buf->data[0] + y * main_buf->linesize[0] + s->rgba_map[A];
for (x = 0; x < main_buf->width; x++) {
*pout = *pin;
pin += 1;
}
}
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+static int activate(AVFilterContext *ctx)
{
- AVFilterContext *ctx = inlink->dst;
- AlphaMergeContext *merge = ctx->priv;
+ AVFilterLink *outlink = ctx->outputs[0];
+ AlphaMergeContext *s = ctx->priv;
+ int ret;
- int ret = 0;
- int is_alpha = (inlink == ctx->inputs[1]);
- struct FFBufQueue *queue =
- (is_alpha ? &merge->queue_alpha : &merge->queue_main);
- ff_bufqueue_add(ctx, queue, buf);
+ FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
- do {
- AVFrame *main_buf, *alpha_buf;
+ if (!s->main_frame) {
+ ret = ff_inlink_consume_frame(ctx->inputs[0], &s->main_frame);
+ if (ret < 0)
+ return ret;
+ }
- if (!ff_bufqueue_peek(&merge->queue_main, 0) ||
- !ff_bufqueue_peek(&merge->queue_alpha, 0)) break;
+ if (!s->alpha_frame) {
+ ret = ff_inlink_consume_frame(ctx->inputs[1], &s->alpha_frame);
+ if (ret < 0)
+ return ret;
+ }
- main_buf = ff_bufqueue_get(&merge->queue_main);
- alpha_buf = ff_bufqueue_get(&merge->queue_alpha);
+ if (s->main_frame && s->alpha_frame) {
+ if (!ctx->is_disabled)
+ draw_frame(ctx, s->main_frame, s->alpha_frame);
+ ret = ff_filter_frame(outlink, s->main_frame);
+ av_frame_free(&s->alpha_frame);
+ s->main_frame = NULL;
+ return ret;
+ }
- draw_frame(ctx, main_buf, alpha_buf);
- ret = ff_filter_frame(ctx->outputs[0], main_buf);
- av_frame_free(&alpha_buf);
- } while (ret >= 0);
- return ret;
-}
+ FF_FILTER_FORWARD_STATUS(ctx->inputs[0], outlink);
+ FF_FILTER_FORWARD_STATUS(ctx->inputs[1], outlink);
-static int request_frame(AVFilterLink *outlink)
-{
- AVFilterContext *ctx = outlink->src;
- AlphaMergeContext *merge = ctx->priv;
- int in, ret;
+ if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
+ !ff_outlink_get_status(ctx->inputs[0]) &&
+ !s->main_frame) {
+ ff_inlink_request_frame(ctx->inputs[0]);
+ return 0;
+ }
- in = ff_bufqueue_peek(&merge->queue_main, 0) ? 1 : 0;
- ret = ff_request_frame(ctx->inputs[in]);
- if (ret < 0)
- return ret;
- return 0;
+ if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
+ !ff_outlink_get_status(ctx->inputs[1]) &&
+ !s->alpha_frame) {
+ ff_inlink_request_frame(ctx->inputs[1]);
+ return 0;
+ }
+
+ return FFERROR_NOT_READY;
}
static const AVFilterPad alphamerge_inputs[] = {
.name = "main",
.type = AVMEDIA_TYPE_VIDEO,
.config_props = config_input_main,
- .filter_frame = filter_frame,
.needs_writable = 1,
},{
.name = "alpha",
.type = AVMEDIA_TYPE_VIDEO,
- .filter_frame = filter_frame,
},
{ NULL }
};
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
.config_props = config_output,
- .request_frame = request_frame,
},
{ NULL }
};
+static const AVOption alphamerge_options[] = {
+ { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(alphamerge);
+
AVFilter ff_vf_alphamerge = {
.name = "alphamerge",
.description = NULL_IF_CONFIG_SMALL("Copy the luma value of the second "
"input into the alpha channel of the first input."),
- .uninit = uninit,
.priv_size = sizeof(AlphaMergeContext),
+ .priv_class = &alphamerge_class,
.query_formats = query_formats,
.inputs = alphamerge_inputs,
.outputs = alphamerge_outputs,
+ .activate = activate,
+ .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
};