[FFmpeg-devel] [PATCH] vf_overlay: add support to RGBA packed input and output
Stefano Sabatini
stefasab at gmail.com
Wed Oct 26 20:04:47 CEST 2011
Also add support to alpha pre-multiplication in the RGBA path.
Based on the work of Mark Himsley <mark at mdsh.com>.
---
doc/filters.texi | 21 ++++++-
libavfilter/vf_overlay.c | 141 ++++++++++++++++++++++++++++++++++++++++------
2 files changed, 142 insertions(+), 20 deletions(-)
diff --git a/doc/filters.texi b/doc/filters.texi
index 76266af..bcd5534 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -1147,6 +1147,7 @@ framework.
The filter does not take parameters.
+ at anchor{format}
@section format
Convert the input video to one of the specified pixel formats.
@@ -1630,10 +1631,10 @@ Overlay one video on top of another.
It takes two inputs and one output, the first input is the "main"
video on which the second input is overlayed.
-It accepts the parameters: @var{x}:@var{y}.
+It accepts the parameters: @var{x}:@var{y}:@var{options}.
@var{x} is the x coordinate of the overlayed video on the main video,
- at var{y} is the y coordinate. The parameters are expressions containing
+ at var{y} is the y coordinate. @var{x} and @var{y} are expressions containing
the following parameters:
@table @option
@@ -1650,6 +1651,22 @@ overlay input width and height
same as @var{overlay_w} and @var{overlay_h}
@end table
+ at var{options} is a list of @var{key}=@var{value} pairs, separated by
+":".
+
+The description of the accepted options follows.
+
+ at table @option
+ at item rgba
+If set to 1, force the input to accept inputs in the RGBA
+colorspace. Default value is 0.
+ at end table
+
+The overlay filter needs both main and overlay video inputs to be in
+the same colorspace formats (YUV or RGB depending on the value set by
+the @var{rgba} option), so you may need to add a @ref{format} filter
+before the main or overlay input video.
+
Be aware that frames are taken from each input video in timestamp
order, hence, if their initial timestamps differ, it is a a good idea
to pass the two inputs through a @var{setpts=PTS-STARTPTS} filter to
diff --git a/libavfilter/vf_overlay.c b/libavfilter/vf_overlay.c
index 57c9fe9..6576a14 100644
--- a/libavfilter/vf_overlay.c
+++ b/libavfilter/vf_overlay.c
@@ -33,6 +33,7 @@
#include "libavutil/imgutils.h"
#include "libavutil/mathematics.h"
#include "internal.h"
+#include "drawutils.h"
static const char *var_names[] = {
"main_w", "W", ///< width of the main video
@@ -53,13 +54,30 @@ enum var_name {
#define MAIN 0
#define OVERLAY 1
+#define R 0
+#define G 1
+#define B 2
+#define A 3
+
+#define Y 0
+#define U 1
+#define V 2
+
typedef struct {
const AVClass *class;
int x, y; ///< position of overlayed picture
+ int allow_packed_rgba;
+ uint8_t main_is_packed_rgba;
+ uint8_t main_rgba_map[4];
+ uint8_t main_has_alpha;
+ uint8_t overlay_is_packed_rgba;
+ uint8_t overlay_rgba_map[4];
+
AVFilterBufferRef *overpicref;
- int max_plane_step[4]; ///< steps per pixel for each plane
+ 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
int hsub, vsub; ///< chroma subsampling values
char *x_expr, *y_expr;
@@ -70,6 +88,7 @@ typedef struct {
static const AVOption overlay_options[] = {
{ "x", "set the x expression", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX },
{ "y", "set the y expression", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX },
+ {"rgba", "require packed RGBA in the main input and output", OFFSET(allow_packed_rgba), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
{NULL},
};
@@ -128,14 +147,31 @@ static av_cold void uninit(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
{
- const enum PixelFormat inout_pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
- const enum PixelFormat blend_pix_fmts[] = { PIX_FMT_YUVA420P, PIX_FMT_NONE };
- AVFilterFormats *inout_formats = avfilter_make_format_list(inout_pix_fmts);
- AVFilterFormats *blend_formats = avfilter_make_format_list(blend_pix_fmts);
+ OverlayContext *over = ctx->priv;
+
+ const enum PixelFormat main_pix_fmts_yuv[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
+ const enum PixelFormat overlay_pix_fmts_yuv[] = { PIX_FMT_YUVA420P, PIX_FMT_NONE };
+ const enum PixelFormat pix_fmts_rgba[] = {
+ PIX_FMT_ARGB, PIX_FMT_RGBA,
+ PIX_FMT_ABGR, PIX_FMT_BGRA,
+ PIX_FMT_RGB24, PIX_FMT_BGR24,
+ PIX_FMT_NONE
+ };
+
+ AVFilterFormats *main_formats;
+ AVFilterFormats *overlay_formats;
+
+ if (over->allow_packed_rgba) {
+ main_formats = avfilter_make_format_list(pix_fmts_rgba);
+ overlay_formats = avfilter_make_format_list(pix_fmts_rgba);
+ } else {
+ main_formats = avfilter_make_format_list(main_pix_fmts_yuv);
+ overlay_formats = avfilter_make_format_list(overlay_pix_fmts_yuv);
+ }
- avfilter_formats_ref(inout_formats, &ctx->inputs [MAIN ]->out_formats);
- avfilter_formats_ref(blend_formats, &ctx->inputs [OVERLAY]->out_formats);
- avfilter_formats_ref(inout_formats, &ctx->outputs[MAIN ]->in_formats );
+ 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 );
return 0;
}
@@ -145,10 +181,16 @@ static int config_input_main(AVFilterLink *inlink)
OverlayContext *over = inlink->dst->priv;
const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[inlink->format];
- av_image_fill_max_pixsteps(over->max_plane_step, NULL, pix_desc);
+ av_image_fill_max_pixsteps(over->main_pix_step, NULL, pix_desc);
+
over->hsub = pix_desc->log2_chroma_w;
over->vsub = pix_desc->log2_chroma_h;
+ over->main_is_packed_rgba =
+ ff_fill_rgba_map(over->main_rgba_map, inlink->format) >= 0;
+ over->main_has_alpha = inlink->format == PIX_FMT_YUVA420P ||
+ inlink->format == PIX_FMT_ARGB || inlink->format == PIX_FMT_ABGR ||
+ inlink->format == PIX_FMT_RGBA || inlink->format == PIX_FMT_BGRA;
return 0;
}
@@ -159,6 +201,9 @@ static int config_input_overlay(AVFilterLink *inlink)
char *expr;
double var_values[VAR_VARS_NB], res;
int ret;
+ const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[inlink->format];
+
+ av_image_fill_max_pixsteps(over->overlay_pix_step, NULL, pix_desc);
/* Finish the configuration by evaluating the expressions
now when both inputs are configured. */
@@ -181,6 +226,8 @@ static int config_input_overlay(AVFilterLink *inlink)
goto fail;
over->x = res;
+ over->overlay_is_packed_rgba = ff_fill_rgba_map(over->overlay_rgba_map, inlink->format) >= 0;
+
av_log(ctx, AV_LOG_INFO,
"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,
@@ -200,6 +247,14 @@ static int config_input_overlay(AVFilterLink *inlink)
(int)var_values[VAR_MAIN_W], (int)var_values[VAR_MAIN_H]);
return AVERROR(EINVAL);
}
+
+ if (over->main_is_packed_rgba != over->overlay_is_packed_rgba) {
+ av_log(ctx, AV_LOG_ERROR,
+ "Main and overlay are not similar formats, cannot mix YUV and RGB.\n"
+ "Insert a format filter to change the main or overlay format.\n");
+ return AVERROR(EINVAL);
+ }
+
return 0;
fail:
@@ -289,21 +344,71 @@ static void blend_slice(AVFilterContext *ctx,
start_y = FFMAX(y, slice_y);
height = end_y - start_y;
- if (dst->format == PIX_FMT_BGR24 || dst->format == PIX_FMT_RGB24) {
- uint8_t *dp = dst->data[0] + x * 3 + start_y * dst->linesize[0];
+ if (over->main_is_packed_rgba) {
+ uint8_t *dp = dst->data[0] + x * over->main_pix_step[0] +
+ start_y * dst->linesize[0];
uint8_t *sp = src->data[0];
- int b = dst->format == PIX_FMT_BGR24 ? 2 : 0;
- int r = dst->format == PIX_FMT_BGR24 ? 0 : 2;
+ uint8_t alpha; ///< the amount of overlay to blend on to main
if (slice_y > y)
sp += (slice_y - y) * src->linesize[0];
for (i = 0; i < height; i++) {
uint8_t *d = dp, *s = sp;
for (j = 0; j < width; j++) {
- d[r] = (d[r] * (0xff - s[3]) + s[0] * s[3] + 128) >> 8;
- d[1] = (d[1] * (0xff - s[3]) + s[1] * s[3] + 128) >> 8;
- d[b] = (d[b] * (0xff - s[3]) + s[2] * s[3] + 128) >> 8;
- d += 3;
- s += 4;
+ // compute the blend multiplication of overlay over the main
+ alpha = s[over->overlay_rgba_map[A]];
+ // if the main channel has an alpha channel, alpha has to be calculated
+ // to create an un-premultiplied (straight) alpha value
+ if (over->main_has_alpha) {
+ // apply the general equation:
+ // alpha = alpha_overlay / ((alpha_main + alpha_overlay) - alpha_main * alpha_overlay)
+ //
+ // if alpha_main = 0 => alpha = 0
+ // if alpha_main = 1 => alpha = alpha_overlay
+ switch (alpha) {
+ case 0:
+ case 0xff:
+ break;
+ default:
+ // the un-premultiplied calculation is:
+ // (255 * 255 * overlay_alpha) / ( 255 * (overlay_alpha + main_alpha) - (overlay_alpha * main_alpha) )
+ alpha =
+ // the next line is a faster version of: 255 * 255 * alpha
+ ( (alpha << 16) - (alpha << 9) + alpha )
+ / (
+ // the next line is a faster version of: 255 * (blend + d[over->inout_rgba_map[A]])
+ ((alpha + d[over->main_rgba_map[A]]) << 8 ) - (alpha + d[over->main_rgba_map[A]])
+ - d[over->main_rgba_map[A]] * alpha
+ );
+ }
+ }
+ switch (alpha) {
+ case 0:
+ break;
+ case 0xff:
+ d[over->main_rgba_map[R]] = s[over->overlay_rgba_map[R]];
+ d[over->main_rgba_map[G]] = s[over->overlay_rgba_map[G]];
+ d[over->main_rgba_map[B]] = s[over->overlay_rgba_map[B]];
+ break;
+ default:
+ d[over->main_rgba_map[R]] = (d[over->main_rgba_map[R]] * (255 - alpha) + s[over->overlay_rgba_map[R]] * alpha) / 255;
+ d[over->main_rgba_map[G]] = (d[over->main_rgba_map[G]] * (255 - alpha) + s[over->overlay_rgba_map[G]] * alpha) / 255;
+ d[over->main_rgba_map[B]] = (d[over->main_rgba_map[B]] * (255 - alpha) + s[over->overlay_rgba_map[B]] * alpha) / 255;
+ }
+ if (over->main_has_alpha) {
+ switch (alpha) {
+ case 0:
+ break;
+ case 0xff:
+ d[over->main_rgba_map[A]] = s[over->overlay_rgba_map[A]];
+ break;
+ default:
+ d[over->main_rgba_map[A]] = (
+ (d[over->main_rgba_map[A]] << 8) + (0x100 - d[over->main_rgba_map[A]]) * s[over->overlay_rgba_map[A]]
+ ) >> 8;
+ }
+ }
+ d += over->main_pix_step[0];
+ s += over->overlay_pix_step[0];
}
dp += dst->linesize[0];
sp += src->linesize[0];
--
1.7.4.1
More information about the ffmpeg-devel
mailing list