[FFmpeg-cvslog] lavfi: Add drawbox_vaapi filter

Haihao Xiang git at videolan.org
Thu Apr 18 10:07:58 EEST 2024


ffmpeg | branch: master | Haihao Xiang <haihao.xiang at intel.com> | Mon Mar 18 14:06:15 2024 +0800| [5c55e4e2975dd6e577fb1b4597e5292496ec8cbb] | committer: Haihao Xiang

lavfi: Add drawbox_vaapi filter

Signed-off-by: Haihao Xiang <haihao.xiang at intel.com>

> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=5c55e4e2975dd6e577fb1b4597e5292496ec8cbb
---

 configure                      |   1 +
 doc/filters.texi               |  85 ++++++++++
 libavfilter/Makefile           |   1 +
 libavfilter/allfilters.c       |   1 +
 libavfilter/vf_drawbox_vaapi.c | 369 +++++++++++++++++++++++++++++++++++++++++
 5 files changed, 457 insertions(+)

diff --git a/configure b/configure
index 4cd4fbecb7..18eeca89f2 100755
--- a/configure
+++ b/configure
@@ -3957,6 +3957,7 @@ vstack_qsv_filter_select="qsvvpp"
 xstack_qsv_filter_deps="libmfx"
 xstack_qsv_filter_select="qsvvpp"
 pad_vaapi_filter_deps="vaapi_1"
+drawbox_vaapi_filter_deps="vaapi_1"
 
 # examples
 avio_http_serve_files_deps="avformat avutil fork"
diff --git a/doc/filters.texi b/doc/filters.texi
index 8599bc4ffe..665246b038 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -28032,6 +28032,91 @@ input sample aspect ratio
 input display aspect ratio, it is the same as (@var{iw} / @var{ih}) * @var{sar}
 @end table
 
+ at section drawbox_vaapi
+
+Draw a colored box on the input image.
+
+It accepts the following parameters:
+
+ at table @option
+ at item x
+ at item y
+The expressions which specify the top left corner coordinates of the box. It defaults to 0.
+
+ at item width, w
+ at item height, h
+The expressions which specify the width and height of the box; if 0 they are interpreted as
+the input width and height. It defaults to 0.
+
+ at item color, c
+Specify the color of the box to write. For the general syntax of this option,
+check the @ref{color syntax,,"Color" section in the ffmpeg-utils manual,ffmpeg-utils}.
+
+ at item thickness, t
+The expression which sets the thickness of the box edge.
+A value of @code{fill} will create a filled box. Default value is @code{3}.
+
+See below for the list of accepted constants.
+
+ at item replace
+With value @code{1}, the pixels of the painted box will overwrite the video's color and alpha pixels.
+Default is @code{0}, which composites the box onto the input video.
+ at end table
+
+The parameters for @var{x}, @var{y}, @var{w} and @var{h} and @var{t} are expressions containing the
+following constants:
+
+ at table @option
+ at item in_h, ih
+ at item in_w, iw
+The input width and height.
+
+ at item x
+ at item y
+The x and y offset coordinates where the box is drawn.
+
+ at item w
+ at item h
+The width and height of the drawn box.
+
+ at item t
+The thickness of the drawn box.
+
+ at end table
+
+ at subsection Examples
+
+ at itemize
+ at item
+Draw a black box around the edge of the input image:
+ at example
+drawbox
+ at end example
+
+ at item
+Draw a box with color red and an opacity of 50%:
+ at example
+drawbox=10:20:200:60:red@@0.5
+ at end example
+
+The previous example can be specified as:
+ at example
+drawbox=x=10:y=20:w=200:h=60:color=red@@0.5
+ at end example
+
+ at item
+Fill the box with pink color:
+ at example
+drawbox=x=10:y=10:w=100:h=100:color=pink@@0.5:t=fill
+ at end example
+
+ at item
+Draw a 2-pixel red 2.40:1 mask:
+ at example
+drawbox=x=-t:y=0.5*(ih-iw/2.4)-t:w=iw+t*2:h=iw/2.4+t*2:t=2:c=red
+ at end example
+ at end itemize
+
 @c man end VAAPI VIDEO FILTERS
 
 @chapter Vulkan Video Filters
diff --git a/libavfilter/Makefile b/libavfilter/Makefile
index babcc7b676..8571e9e2af 100644
--- a/libavfilter/Makefile
+++ b/libavfilter/Makefile
@@ -582,6 +582,7 @@ OBJS-$(CONFIG_HSTACK_QSV_FILTER)             += vf_stack_qsv.o framesync.o
 OBJS-$(CONFIG_VSTACK_QSV_FILTER)             += vf_stack_qsv.o framesync.o
 OBJS-$(CONFIG_XSTACK_QSV_FILTER)             += vf_stack_qsv.o framesync.o
 OBJS-$(CONFIG_PAD_VAAPI_FILTER)              += vf_pad_vaapi.o vaapi_vpp.o
+OBJS-$(CONFIG_DRAWBOX_VAAPI_FILTER)          += vf_drawbox_vaapi.o vaapi_vpp.o
 
 OBJS-$(CONFIG_ALLRGB_FILTER)                 += vsrc_testsrc.o
 OBJS-$(CONFIG_ALLYUV_FILTER)                 += vsrc_testsrc.o
diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
index 1e024b3376..c532682fc2 100644
--- a/libavfilter/allfilters.c
+++ b/libavfilter/allfilters.c
@@ -547,6 +547,7 @@ extern const AVFilter ff_vf_hstack_qsv;
 extern const AVFilter ff_vf_vstack_qsv;
 extern const AVFilter ff_vf_xstack_qsv;
 extern const AVFilter ff_vf_pad_vaapi;
+extern const AVFilter ff_vf_drawbox_vaapi;
 
 extern const AVFilter ff_vsrc_allrgb;
 extern const AVFilter ff_vsrc_allyuv;
diff --git a/libavfilter/vf_drawbox_vaapi.c b/libavfilter/vf_drawbox_vaapi.c
new file mode 100644
index 0000000000..1081d463e9
--- /dev/null
+++ b/libavfilter/vf_drawbox_vaapi.c
@@ -0,0 +1,369 @@
+/*
+ * 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
+ */
+
+#include "libavutil/colorspace.h"
+#include "libavutil/eval.h"
+#include "libavutil/opt.h"
+
+#include "avfilter.h"
+#include "internal.h"
+#include "vaapi_vpp.h"
+#include "video.h"
+
+static const char *const var_names[] = {
+    "in_h", "ih",
+    "in_w", "iw",
+    "x",
+    "y",
+    "h",
+    "w",
+    "t",
+    "fill",
+    NULL
+};
+
+enum var_name {
+    VAR_IN_H, VAR_IH,
+    VAR_IN_W, VAR_IW,
+    VAR_X,
+    VAR_Y,
+    VAR_H,
+    VAR_W,
+    VAR_T,
+    VAR_MAX,
+    VARS_NB
+};
+
+static const int NUM_EXPR_EVALS = 5;
+
+typedef struct DrawboxVAAPIContext {
+    VAAPIVPPContext vpp_ctx; // must be the first field
+    VARectangle outer_rect, inner_rect;
+
+    /* The hardware frame context containing the frames for outer_rect. */
+    AVBufferRef *outer_frames_ref;
+    AVHWFramesContext *outer_frames;
+    AVFrame *outer_frame;
+
+    char *x_expr;
+    char *y_expr;
+    char *w_expr;
+    char *h_expr;
+    char *t_expr;
+
+    int w, h;
+    int x, y;
+    int replace;
+    uint32_t thickness;
+    uint8_t drawbox_rgba[4];
+
+    int fill;
+
+} DrawboxVAAPIContext;
+
+static int drawbox_vaapi_config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *avctx = outlink->src;
+    AVFilterLink *inlink = avctx->inputs[0];
+    DrawboxVAAPIContext *ctx = avctx->priv;
+    VAAPIVPPContext *vpp_ctx = avctx->priv;
+    double var_values[VARS_NB], res;
+    int ret, i;
+    char *expr;
+
+    var_values[VAR_IN_W] = var_values[VAR_IW] = inlink->w;
+    var_values[VAR_IN_H] = var_values[VAR_IH] = inlink->h;
+    var_values[VAR_X] = NAN;
+    var_values[VAR_Y] = NAN;
+    var_values[VAR_H] = NAN;
+    var_values[VAR_W] = NAN;
+    var_values[VAR_T] = NAN;
+
+    for (i = 0; i <= NUM_EXPR_EVALS; i++) {
+        /* evaluate expressions, fail on last iteration */
+        var_values[VAR_MAX] = inlink->w;
+        if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->x_expr),
+                                          var_names, var_values,
+                                          NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
+            goto fail;
+        ctx->x = var_values[VAR_X] = res;
+
+        var_values[VAR_MAX] = inlink->h;
+        if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->y_expr),
+                                          var_names, var_values,
+                                          NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
+            goto fail;
+        ctx->y = var_values[VAR_Y] = res;
+
+        var_values[VAR_MAX] = inlink->w - ctx->x;
+        if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->w_expr),
+                                          var_names, var_values,
+                                          NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
+            goto fail;
+        ctx->w = var_values[VAR_W] = res;
+
+        var_values[VAR_MAX] = inlink->h - ctx->y;
+        if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->h_expr),
+                                          var_names, var_values,
+                                          NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
+            goto fail;
+        ctx->h = var_values[VAR_H] = res;
+
+        var_values[VAR_MAX] = INT_MAX;
+        if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->t_expr),
+                                          var_names, var_values,
+                                          NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
+            goto fail;
+        ctx->thickness = var_values[VAR_T] = res;
+    }
+
+    /* Sanity check */
+    ctx->w = (ctx->w > 0) ? ctx->w : inlink->w;
+    ctx->h = (ctx->h > 0) ? ctx->h : inlink->h;
+    if (ctx->x + ctx->w > inlink->w)
+        ctx->w = inlink->w - ctx->x;
+    if (ctx->y + ctx->h > inlink->h)
+        ctx->h = inlink->h - ctx->y;
+
+    ctx->outer_rect.x = ctx->x;
+    ctx->outer_rect.y = ctx->y;
+    ctx->outer_rect.width = ctx->w;
+    ctx->outer_rect.height = ctx->h;
+
+    if (ctx->outer_rect.width <= ctx->thickness * 2 ||
+        ctx->outer_rect.height <= ctx->thickness * 2) {
+        ctx->fill = 1;
+    } else {
+        ctx->fill = 0;
+        ctx->inner_rect.x = ctx->outer_rect.x + ctx->thickness;
+        ctx->inner_rect.y = ctx->outer_rect.y + ctx->thickness;
+        ctx->inner_rect.width = ctx->outer_rect.width - ctx->thickness * 2;
+        ctx->inner_rect.height = ctx->outer_rect.height - ctx->thickness * 2;
+    }
+
+    vpp_ctx->output_width = inlink->w;
+    vpp_ctx->output_height = inlink->h;
+
+    ret = ff_vaapi_vpp_config_output(outlink);
+    if (ret < 0)
+        return ret;
+
+    ctx->outer_frames_ref = av_hwframe_ctx_alloc(vpp_ctx->device_ref);
+    if (!ctx->outer_frames_ref) {
+        return AVERROR(ENOMEM);
+    }
+
+    ctx->outer_frames = (AVHWFramesContext*)ctx->outer_frames_ref->data;
+
+    ctx->outer_frames->format    = AV_PIX_FMT_VAAPI;
+    ctx->outer_frames->sw_format = vpp_ctx->input_frames->sw_format;
+    ctx->outer_frames->width     = ctx->outer_rect.width;
+    ctx->outer_frames->height    = ctx->outer_rect.height;
+
+    return av_hwframe_ctx_init(ctx->outer_frames_ref);
+
+fail:
+    av_log(avctx, AV_LOG_ERROR,
+           "Error when evaluating the expression '%s'.\n",
+           expr);
+    return ret;
+}
+
+static int drawbox_vaapi_filter_frame(AVFilterLink *link, AVFrame *input_frame)
+{
+    AVFilterContext *avctx = link->dst;
+    AVFilterLink *outlink = avctx->outputs[0];
+    VAAPIVPPContext *vpp_ctx = avctx->priv;
+    DrawboxVAAPIContext *drawbox_ctx = avctx->priv;
+    AVFrame *output_frame = NULL;
+    VAProcPipelineParameterBuffer box_params;
+    VAProcPipelineParameterBuffer params[3];
+    VABlendState blend_state = {
+        .flags = VA_BLEND_GLOBAL_ALPHA,
+    };
+    VARectangle box[4];
+    int err, nb_params = 0;
+
+    if (!input_frame->hw_frames_ctx ||
+        vpp_ctx->va_context == VA_INVALID_ID) {
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+
+    if (!drawbox_ctx->outer_frame) {
+        drawbox_ctx->outer_frame = av_frame_alloc();
+        if (!drawbox_ctx->outer_frame) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        err = av_hwframe_get_buffer(drawbox_ctx->outer_frames_ref, drawbox_ctx->outer_frame, 0);
+        if (err < 0) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        /* Create image for the outer rect */
+        err = ff_vaapi_vpp_init_params(avctx, &box_params,
+                                       input_frame, drawbox_ctx->outer_frame);
+        if (err < 0)
+            goto fail;
+
+        blend_state.global_alpha = 0.0f;
+        box_params.surface_region = &drawbox_ctx->outer_rect;
+        box_params.blend_state = &blend_state;
+        box_params.output_background_color = (drawbox_ctx->drawbox_rgba[3] << 24 |
+                                              drawbox_ctx->drawbox_rgba[0] << 16 |
+                                              drawbox_ctx->drawbox_rgba[1] << 8 |
+                                              drawbox_ctx->drawbox_rgba[2]);
+
+        err = ff_vaapi_vpp_render_picture(avctx, &box_params, drawbox_ctx->outer_frame);
+        if (err < 0)
+            goto fail;
+    }
+
+    /* Draw outer & inner rects on the input video, then we can get a box*/
+    output_frame = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    if (!output_frame) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    err = av_frame_copy_props(output_frame, input_frame);
+    if (err < 0)
+        goto fail;
+
+    err = ff_vaapi_vpp_init_params(avctx, &params[nb_params],
+                                   input_frame, output_frame);
+    if (err < 0)
+        goto fail;
+
+    box[0].x = 0;
+    box[0].y = 0;
+    box[0].width = link->w;
+    box[0].height = link->h;
+    params[nb_params].surface_region = &box[0];
+    params[nb_params].output_background_color = 0;
+    nb_params++;
+
+    err = ff_vaapi_vpp_init_params(avctx, &params[nb_params],
+                                   drawbox_ctx->outer_frame, output_frame);
+    if (err < 0)
+        goto fail;
+
+    box[1] = drawbox_ctx->outer_rect;
+    if (drawbox_ctx->drawbox_rgba[3] != 255 && !drawbox_ctx->replace) {
+        blend_state.global_alpha = (float)drawbox_ctx->drawbox_rgba[3] / 255;
+        params[nb_params].blend_state = &blend_state;
+    }
+    params[nb_params].output_region = &box[1];
+    params[nb_params].output_background_color = 0;
+    nb_params++;
+
+    if (!drawbox_ctx->fill) {
+        box[3] = box[2] = drawbox_ctx->inner_rect;
+        params[nb_params] = params[0];
+        params[nb_params].surface_region = &box[2];
+        params[nb_params].output_region = &box[3];
+        params[nb_params].output_background_color = 0;
+        nb_params++;
+    }
+
+    err = ff_vaapi_vpp_render_pictures(avctx, params, nb_params, output_frame);
+    if (err < 0)
+        goto fail;
+
+    av_frame_free(&input_frame);
+
+    return ff_filter_frame(outlink, output_frame);
+
+fail:
+    av_frame_free(&input_frame);
+    av_frame_free(&output_frame);
+    return err;
+}
+
+static av_cold int drawbox_vaapi_init(AVFilterContext *avctx)
+{
+    VAAPIVPPContext *vpp_ctx = avctx->priv;
+
+    ff_vaapi_vpp_ctx_init(avctx);
+    vpp_ctx->pipeline_uninit = ff_vaapi_vpp_pipeline_uninit;
+    vpp_ctx->output_format = AV_PIX_FMT_NONE;
+
+    return 0;
+}
+
+static av_cold void drawbox_vaapi_uninit(AVFilterContext *avctx)
+{
+    DrawboxVAAPIContext *ctx = avctx->priv;
+
+    av_frame_free(&ctx->outer_frame);
+    av_buffer_unref(&ctx->outer_frames_ref);
+    ff_vaapi_vpp_ctx_uninit(avctx);
+}
+
+#define OFFSET(x) offsetof(DrawboxVAAPIContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption drawbox_vaapi_options[] = {
+    { "x",         "set horizontal position of the left box edge", OFFSET(x_expr),       AV_OPT_TYPE_STRING, { .str="0" },       0, 0, FLAGS },
+    { "y",         "set vertical position of the top box edge",    OFFSET(y_expr),       AV_OPT_TYPE_STRING, { .str="0" },       0, 0, FLAGS },
+    { "width",     "set width of the box",                         OFFSET(w_expr),       AV_OPT_TYPE_STRING, { .str="0" },       0, 0, FLAGS },
+    { "w",         "set width of the box",                         OFFSET(w_expr),       AV_OPT_TYPE_STRING, { .str="0" },       0, 0, FLAGS },
+    { "height",    "set height of the box",                        OFFSET(h_expr),       AV_OPT_TYPE_STRING, { .str="0" },       0, 0, FLAGS },
+    { "h",         "set height of the box",                        OFFSET(h_expr),       AV_OPT_TYPE_STRING, { .str="0" },       0, 0, FLAGS },
+    { "color",     "set color of the box",                         OFFSET(drawbox_rgba), AV_OPT_TYPE_COLOR,  { .str = "black" }, 0, 0, FLAGS },
+    { "c",         "set color of the box",                         OFFSET(drawbox_rgba), AV_OPT_TYPE_COLOR,  { .str = "black" }, 0, 0, FLAGS },
+    { "thickness", "set the box thickness",                        OFFSET(t_expr),       AV_OPT_TYPE_STRING, { .str="3" },       0, 0, FLAGS },
+    { "t",         "set the box thickness",                        OFFSET(t_expr),       AV_OPT_TYPE_STRING, { .str="3" },       0, 0, FLAGS },
+    { "replace",   "replace color",                                OFFSET(replace),      AV_OPT_TYPE_BOOL,   { .i64=0   },       0, 1, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(drawbox_vaapi);
+
+static const AVFilterPad drawbox_vaapi_inputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = drawbox_vaapi_filter_frame,
+        .config_props = &ff_vaapi_vpp_config_input,
+    },
+};
+
+static const AVFilterPad drawbox_vaapi_outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+        .config_props = &drawbox_vaapi_config_output,
+    },
+};
+
+const AVFilter ff_vf_drawbox_vaapi = {
+    .name           = "drawbox_vaapi",
+    .description    = NULL_IF_CONFIG_SMALL("Draw a colored box on the input video."),
+    .priv_size      = sizeof(DrawboxVAAPIContext),
+    .priv_class     = &drawbox_vaapi_class,
+    .init           = &drawbox_vaapi_init,
+    .uninit         = &drawbox_vaapi_uninit,
+    FILTER_INPUTS(drawbox_vaapi_inputs),
+    FILTER_OUTPUTS(drawbox_vaapi_outputs),
+    FILTER_QUERY_FUNC(&ff_vaapi_vpp_query_formats),
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};



More information about the ffmpeg-cvslog mailing list