git.sesse.net Git - ffmpeg/blob - libavfilter/vf_addroi.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "libavutil/avassert.h"
  20 #include "libavutil/eval.h"
  21 #include "libavutil/opt.h"
  22 #include "avfilter.h"
  23 #include "internal.h"
  24
  25 enum {
  26     X, Y, W, H,
  27     NB_PARAMS,
  28 };
  29 static const char addroi_param_names[] = {
  30     'x', 'y', 'w', 'h',
  31 };
  32
  33 enum {
  34     VAR_IW,
  35     VAR_IH,
  36     NB_VARS,
  37 };
  38 static const char *const addroi_var_names[] = {
  39     "iw",
  40     "ih",
  41 };
  42
  43 typedef struct AddROIContext {
  44     const AVClass *class;
  45
  46     char   *region_str[NB_PARAMS];
  47     AVExpr *region_expr[NB_PARAMS];
  48
  49     int region[NB_PARAMS];
  50     AVRational qoffset;
  51
  52     int clear;
  53 } AddROIContext;
  54
  55 static int addroi_config_input(AVFilterLink *inlink)
  56 {
  57     AVFilterContext *avctx = inlink->dst;
  58     AddROIContext     *ctx = avctx->priv;
  59     int i;
  60     double vars[NB_VARS];
  61     double val;
  62
  63     vars[VAR_IW] = inlink->w;
  64     vars[VAR_IH] = inlink->h;
  65
  66     for (i = 0; i < NB_PARAMS; i++) {
  67         int max_value;
  68         switch (i) {
  69         case X: max_value = inlink->w;                  break;
  70         case Y: max_value = inlink->h;                  break;
  71         case W: max_value = inlink->w - ctx->region[X]; break;
  72         case H: max_value = inlink->h - ctx->region[Y]; break;
  73         }
  74
  75         val = av_expr_eval(ctx->region_expr[i], vars, NULL);
  76         if (val < 0.0) {
  77             av_log(avctx, AV_LOG_WARNING, "Calculated value %g for %c is "
  78                    "less than zero - using zero instead.\n", val,
  79                    addroi_param_names[i]);
  80             val = 0.0;
  81         } else if (val > max_value) {
  82             av_log(avctx, AV_LOG_WARNING, "Calculated value %g for %c is "
  83                    "greater than maximum allowed value %d - "
  84                    "using %d instead.\n", val, addroi_param_names[i],
  85                    max_value, max_value);
  86             val = max_value;
  87         }
  88         ctx->region[i] = val;
  89     }
  90
  91     return 0;
  92 }
  93
  94 static int addroi_filter_frame(AVFilterLink *inlink, AVFrame *frame)
  95 {
  96     AVFilterContext *avctx = inlink->dst;
  97     AVFilterLink  *outlink = avctx->outputs[0];
  98     AddROIContext     *ctx = avctx->priv;
  99     AVRegionOfInterest *roi;
 100     AVFrameSideData *sd;
 101     int err;
 102
 103     if (ctx->clear) {
 104         av_frame_remove_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
 105         sd = NULL;
 106     } else {
 107         sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
 108     }
 109     if (sd) {
 110         const AVRegionOfInterest *old_roi;
 111         uint32_t old_roi_size;
 112         AVBufferRef *roi_ref;
 113         int nb_roi, i;
 114
 115         old_roi = (const AVRegionOfInterest*)sd->data;
 116         old_roi_size = old_roi->self_size;
 117         av_assert0(old_roi_size && sd->size % old_roi_size == 0);
 118         nb_roi = sd->size / old_roi_size + 1;
 119
 120         roi_ref = av_buffer_alloc(sizeof(*roi) * nb_roi);
 121         if (!roi_ref) {
 122             err = AVERROR(ENOMEM);
 123             goto fail;
 124         }
 125         roi = (AVRegionOfInterest*)roi_ref->data;
 126
 127         for (i = 0; i < nb_roi - 1; i++) {
 128             old_roi = (const AVRegionOfInterest*)
 129                 (sd->data + old_roi_size * i);
 130
 131             roi[i] = (AVRegionOfInterest) {
 132                 .self_size = sizeof(*roi),
 133                 .top       = old_roi->top,
 134                 .bottom    = old_roi->bottom,
 135                 .left      = old_roi->left,
 136                 .right     = old_roi->right,
 137                 .qoffset   = old_roi->qoffset,
 138             };
 139         }
 140
 141         roi[nb_roi - 1] = (AVRegionOfInterest) {
 142             .self_size = sizeof(*roi),
 143             .top       = ctx->region[Y],
 144             .bottom    = ctx->region[Y] + ctx->region[H],
 145             .left      = ctx->region[X],
 146             .right     = ctx->region[X] + ctx->region[W],
 147             .qoffset   = ctx->qoffset,
 148         };
 149
 150         av_frame_remove_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
 151
 152         sd = av_frame_new_side_data_from_buf(frame,
 153                                              AV_FRAME_DATA_REGIONS_OF_INTEREST,
 154                                              roi_ref);
 155         if (!sd) {
 156             av_buffer_unref(&roi_ref);
 157             err = AVERROR(ENOMEM);
 158             goto fail;
 159         }
 160
 161     } else {
 162         sd = av_frame_new_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST,
 163                                     sizeof(AVRegionOfInterest));
 164         if (!sd) {
 165             err = AVERROR(ENOMEM);
 166             goto fail;
 167         }
 168         roi = (AVRegionOfInterest*)sd->data;
 169         *roi = (AVRegionOfInterest) {
 170             .self_size = sizeof(*roi),
 171             .top       = ctx->region[Y],
 172             .bottom    = ctx->region[Y] + ctx->region[H],
 173             .left      = ctx->region[X],
 174             .right     = ctx->region[X] + ctx->region[W],
 175             .qoffset   = ctx->qoffset,
 176         };
 177     }
 178
 179     return ff_filter_frame(outlink, frame);
 180
 181 fail:
 182     av_frame_free(&frame);
 183     return err;
 184 }
 185
 186 static av_cold int addroi_init(AVFilterContext *avctx)
 187 {
 188     AddROIContext *ctx = avctx->priv;
 189     int i, err;
 190
 191     for (i = 0; i < NB_PARAMS; i++) {
 192         err = av_expr_parse(&ctx->region_expr[i], ctx->region_str[i],
 193                             addroi_var_names, NULL, NULL, NULL, NULL,
 194                             0, avctx);
 195         if (err < 0) {
 196             av_log(ctx, AV_LOG_ERROR,
 197                    "Error parsing %c expression '%s'.\n",
 198                    addroi_param_names[i], ctx->region_str[i]);
 199             return err;
 200         }
 201     }
 202
 203     return 0;
 204 }
 205
 206 static av_cold void addroi_uninit(AVFilterContext *avctx)
 207 {
 208     AddROIContext *ctx = avctx->priv;
 209     int i;
 210
 211     for (i = 0; i < NB_PARAMS; i++) {
 212         av_expr_free(ctx->region_expr[i]);
 213         ctx->region_expr[i] = NULL;
 214     }
 215 }
 216
 217 #define OFFSET(x) offsetof(AddROIContext, x)
 218 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
 219 static const AVOption addroi_options[] = {
 220     { "x", "Region distance from left edge of frame.",
 221       OFFSET(region_str[X]), AV_OPT_TYPE_STRING, { .str = "0" }, .flags = FLAGS },
 222     { "y", "Region distance from top edge of frame.",
 223       OFFSET(region_str[Y]), AV_OPT_TYPE_STRING, { .str = "0" }, .flags = FLAGS },
 224     { "w", "Region width.",
 225       OFFSET(region_str[W]), AV_OPT_TYPE_STRING, { .str = "0" }, .flags = FLAGS },
 226     { "h", "Region height.",
 227       OFFSET(region_str[H]), AV_OPT_TYPE_STRING, { .str = "0" }, .flags = FLAGS },
 228
 229     { "qoffset", "Quantisation offset to apply in the region.",
 230       OFFSET(qoffset), AV_OPT_TYPE_RATIONAL, { .dbl = -0.1 }, -1, +1, FLAGS },
 231
 232     { "clear", "Remove any existing regions of interest before adding the new one.",
 233       OFFSET(clear), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
 234
 235     { NULL }
 236 };
 237
 238 AVFILTER_DEFINE_CLASS(addroi);
 239
 240 static const AVFilterPad addroi_inputs[] = {
 241     {
 242         .name         = "default",
 243         .type         = AVMEDIA_TYPE_VIDEO,
 244         .config_props = addroi_config_input,
 245         .filter_frame = addroi_filter_frame,
 246     },
 247     { NULL }
 248 };
 249
 250 static const AVFilterPad addroi_outputs[] = {
 251     {
 252         .name = "default",
 253         .type = AVMEDIA_TYPE_VIDEO,
 254     },
 255     { NULL }
 256 };
 257
 258 AVFilter ff_vf_addroi = {
 259     .name        = "addroi",
 260     .description = NULL_IF_CONFIG_SMALL("Add region of interest to frame."),
 261     .init        = addroi_init,
 262     .uninit      = addroi_uninit,
 263
 264     .priv_size   = sizeof(AddROIContext),
 265     .priv_class  = &addroi_class,
 266
 267     .inputs      = addroi_inputs,
 268     .outputs     = addroi_outputs,
 269 };