[FFmpeg-devel] [PATCH] vf_overlay: add support to RGBA packed input and output

Michael Niedermayer michaelni at gmx.at
Thu Oct 27 01:01:40 CEST 2011


On Thu, Oct 27, 2011 at 12:25:43AM +0200, Stefano Sabatini wrote:
> On date Wednesday 2011-10-26 20:04:47 +0200, Stefano Sabatini encoded:
> > 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(-)
> 
> Updated with a few fixes / simplifications.
> -- 
> FFmpeg = Formidable & Fantastic Maxi Powerful Ecumenical Guru

>  doc/filters.texi         |   15 ++++-
>  libavfilter/vf_overlay.c |  134 ++++++++++++++++++++++++++++++++++++++++-------
>  2 files changed, 129 insertions(+), 20 deletions(-)
> e4e0f1f3b52dea504c11cdfda765e643f07ca703  0003-vf_overlay-add-support-to-RGB-packed-input-and-outpu.patch
> From 72b3c79a550961b3e215e5f1e6d42da3c362751e Mon Sep 17 00:00:00 2001
> From: Stefano Sabatini <stefasab at gmail.com>
> Date: Mon, 24 Oct 2011 20:00:21 +0200
> Subject: [PATCH] vf_overlay: add support to RGB packed input and output
> 
> Also add support to alpha pre-multiplication in the RGBA path.
> 
> Based on the work of Mark Himsley <mark at mdsh.com>.
> 
> See thread:
> Subject: [FFmpeg-devel] libavfilter: extending overlay filter
> Date: Sun, 13 Mar 2011 14:18:42 +0000
> ---
>  doc/filters.texi         |   15 +++++-
>  libavfilter/vf_overlay.c |  134 +++++++++++++++++++++++++++++++++++++++------
>  2 files changed, 129 insertions(+), 20 deletions(-)
> 
> diff --git a/doc/filters.texi b/doc/filters.texi
> index 76266af..a3b36d7 100644
> --- a/doc/filters.texi
> +++ b/doc/filters.texi
> @@ -1630,10 +1630,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 +1650,17 @@ overlay input width and height
>  same as @var{overlay_w} and @var{overlay_h}
>  @end table
>  
> + at var{options} is an optional 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 filter to accept inputs in the RGB
> +colorspace. Default value is 0.
> + at end table
> +
>  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..6c6864e 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_rgb;
> +    uint8_t main_is_packed_rgb;
> +    uint8_t main_rgba_map[4];
> +    uint8_t main_has_alpha;
> +    uint8_t overlay_is_packed_rgb;
> +    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 },
> +    {"rgb", "force packed RGB in input and output", OFFSET(allow_packed_rgb), 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_rgb[] = {
> +        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_rgb) {
> +        main_formats    = avfilter_make_format_list(pix_fmts_rgb);
> +        overlay_formats = avfilter_make_format_list(pix_fmts_rgb);
> +    } 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_rgb =
> +        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,9 @@ static int config_input_overlay(AVFilterLink *inlink)
>          goto fail;
>      over->x = res;
>  
> +    over->overlay_is_packed_rgb =
> +        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,
> @@ -289,21 +337,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_rgb) {
> +        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;
> +                    }
> +                }

please benchmark this with START/STOP_TIMER against the previous code


[...]

-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

Dictatorship naturally arises out of democracy, and the most aggravated
form of tyranny and slavery out of the most extreme liberty. -- Plato
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 198 bytes
Desc: Digital signature
URL: <http://ffmpeg.org/pipermail/ffmpeg-devel/attachments/20111027/9a7a2e48/attachment.asc>


More information about the ffmpeg-devel mailing list