avfilter/af_sofalizer: speed and clean up fast convolution a little
[ffmpeg.git] / libavfilter / vf_eq.c
index 7bbbaee..c450d5e 100644 (file)
  * very simple video equalizer
  */
 
-/**
- * TODO:
- * - Add support to process_command
- */
-
 #include "libavfilter/internal.h"
 #include "libavutil/common.h"
 #include "libavutil/imgutils.h"
@@ -65,7 +60,7 @@ static void create_lut(EQParameters *param)
 }
 
 static void apply_lut(EQParameters *param, uint8_t *dst, int dst_stride,
-                      uint8_t *src, int src_stride, int w, int h)
+                      const uint8_t *src, int src_stride, int w, int h)
 {
     int x, y;
 
@@ -80,7 +75,7 @@ static void apply_lut(EQParameters *param, uint8_t *dst, int dst_stride,
 }
 
 static void process_c(EQParameters *param, uint8_t *dst, int dst_stride,
-                      uint8_t *src, int src_stride, int w, int h)
+                      const uint8_t *src, int src_stride, int w, int h)
 {
     int x, y, pel;
 
@@ -103,7 +98,7 @@ static void check_values(EQParameters *param, EQContext *eq)
 {
     if (param->contrast == 1.0 && param->brightness == 0.0 && param->gamma == 1.0)
         param->adjust = NULL;
-    else if (param->gamma == 1.0)
+    else if (param->gamma == 1.0 && fabs(param->contrast) < 7.9)
         param->adjust = eq->process;
     else
         param->adjust = apply_lut;
@@ -111,6 +106,7 @@ static void check_values(EQParameters *param, EQContext *eq)
 
 static void set_contrast(EQContext *eq)
 {
+    eq->contrast = av_clipf(av_expr_eval(eq->contrast_pexpr, eq->var_values, eq), -1000.0, 1000.0);
     eq->param[0].contrast = eq->contrast;
     eq->param[0].lut_clean = 0;
     check_values(&eq->param[0], eq);
@@ -118,6 +114,7 @@ static void set_contrast(EQContext *eq)
 
 static void set_brightness(EQContext *eq)
 {
+    eq->brightness = av_clipf(av_expr_eval(eq->brightness_pexpr, eq->var_values, eq), -1.0, 1.0);
     eq->param[0].brightness = eq->brightness;
     eq->param[0].lut_clean = 0;
     check_values(&eq->param[0], eq);
@@ -126,6 +123,13 @@ static void set_brightness(EQContext *eq)
 static void set_gamma(EQContext *eq)
 {
     int i;
+
+    eq->gamma        = av_clipf(av_expr_eval(eq->gamma_pexpr,        eq->var_values, eq), 0.1, 10.0);
+    eq->gamma_r      = av_clipf(av_expr_eval(eq->gamma_r_pexpr,      eq->var_values, eq), 0.1, 10.0);
+    eq->gamma_g      = av_clipf(av_expr_eval(eq->gamma_g_pexpr,      eq->var_values, eq), 0.1, 10.0);
+    eq->gamma_b      = av_clipf(av_expr_eval(eq->gamma_b_pexpr,      eq->var_values, eq), 0.1, 10.0);
+    eq->gamma_weight = av_clipf(av_expr_eval(eq->gamma_weight_pexpr, eq->var_values, eq), 0.0,  1.0);
+
     eq->param[0].gamma = eq->gamma * eq->gamma_g;
     eq->param[1].gamma = sqrt(eq->gamma_b / eq->gamma_g);
     eq->param[2].gamma = sqrt(eq->gamma_r / eq->gamma_g);
@@ -140,6 +144,9 @@ static void set_gamma(EQContext *eq)
 static void set_saturation(EQContext *eq)
 {
     int i;
+
+    eq->saturation = av_clipf(av_expr_eval(eq->saturation_pexpr, eq->var_values, eq), 0.0, 3.0);
+
     for (i = 1; i < 3; i++) {
         eq->param[i].contrast = eq->saturation;
         eq->param[i].lut_clean = 0;
@@ -147,19 +154,77 @@ static void set_saturation(EQContext *eq)
     }
 }
 
+static int set_expr(AVExpr **pexpr, const char *expr, const char *option, void *log_ctx)
+{
+    int ret;
+    AVExpr *old = NULL;
+
+    if (*pexpr)
+        old = *pexpr;
+    ret = av_expr_parse(pexpr, expr, var_names, NULL, NULL, NULL, NULL, 0, log_ctx);
+    if (ret < 0) {
+        av_log(log_ctx, AV_LOG_ERROR,
+               "Error when parsing the expression '%s' for %s\n",
+               expr, option);
+        *pexpr = old;
+        return ret;
+    }
+
+    av_expr_free(old);
+    return 0;
+}
+
 static int initialize(AVFilterContext *ctx)
 {
     EQContext *eq = ctx->priv;
+    int ret;
 
     eq->process = process_c;
 
+    if ((ret = set_expr(&eq->contrast_pexpr,     eq->contrast_expr,     "contrast",     ctx)) < 0 ||
+        (ret = set_expr(&eq->brightness_pexpr,   eq->brightness_expr,   "brightness",   ctx)) < 0 ||
+        (ret = set_expr(&eq->saturation_pexpr,   eq->saturation_expr,   "saturation",   ctx)) < 0 ||
+        (ret = set_expr(&eq->gamma_pexpr,        eq->gamma_expr,        "gamma",        ctx)) < 0 ||
+        (ret = set_expr(&eq->gamma_r_pexpr,      eq->gamma_r_expr,      "gamma_r",      ctx)) < 0 ||
+        (ret = set_expr(&eq->gamma_g_pexpr,      eq->gamma_g_expr,      "gamma_g",      ctx)) < 0 ||
+        (ret = set_expr(&eq->gamma_b_pexpr,      eq->gamma_b_expr,      "gamma_b",      ctx)) < 0 ||
+        (ret = set_expr(&eq->gamma_weight_pexpr, eq->gamma_weight_expr, "gamma_weight", ctx)) < 0 )
+        return ret;
+
     if (ARCH_X86)
         ff_eq_init_x86(eq);
 
-    set_gamma(eq);
-    set_contrast(eq);
-    set_brightness(eq);
-    set_saturation(eq);
+    if (eq->eval_mode == EVAL_MODE_INIT) {
+        set_gamma(eq);
+        set_contrast(eq);
+        set_brightness(eq);
+        set_saturation(eq);
+    }
+
+    return 0;
+}
+
+static void uninit(AVFilterContext *ctx)
+{
+    EQContext *eq = ctx->priv;
+
+    av_expr_free(eq->contrast_pexpr);     eq->contrast_pexpr     = NULL;
+    av_expr_free(eq->brightness_pexpr);   eq->brightness_pexpr   = NULL;
+    av_expr_free(eq->saturation_pexpr);   eq->saturation_pexpr   = NULL;
+    av_expr_free(eq->gamma_pexpr);        eq->gamma_pexpr        = NULL;
+    av_expr_free(eq->gamma_weight_pexpr); eq->gamma_weight_pexpr = NULL;
+    av_expr_free(eq->gamma_r_pexpr);      eq->gamma_r_pexpr      = NULL;
+    av_expr_free(eq->gamma_g_pexpr);      eq->gamma_g_pexpr      = NULL;
+    av_expr_free(eq->gamma_b_pexpr);      eq->gamma_b_pexpr      = NULL;
+}
+
+static int config_props(AVFilterLink *inlink)
+{
+    EQContext *eq = inlink->dst->priv;
+
+    eq->var_values[VAR_N] = 0;
+    eq->var_values[VAR_R] = inlink->frame_rate.num == 0 || inlink->frame_rate.den == 0 ?
+        NAN : av_q2d(inlink->frame_rate);
 
     return 0;
 }
@@ -175,18 +240,21 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_NONE
     };
-
-    ff_set_common_formats(ctx, ff_make_format_list(pixel_fmts_eq));
-
-    return 0;
+    AVFilterFormats *fmts_list = ff_make_format_list(pixel_fmts_eq);
+    if (!fmts_list)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, fmts_list);
 }
 
+#define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts) * av_q2d(tb))
+
 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     AVFilterContext *ctx = inlink->dst;
     AVFilterLink *outlink = inlink->dst->outputs[0];
     EQContext *eq = ctx->priv;
     AVFrame *out;
+    int64_t pos = av_frame_get_pkt_pos(in);
     const AVPixFmtDescriptor *desc;
     int i;
 
@@ -197,13 +265,24 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     av_frame_copy_props(out, in);
     desc = av_pix_fmt_desc_get(inlink->format);
 
+    eq->var_values[VAR_N]   = inlink->frame_count_out;
+    eq->var_values[VAR_POS] = pos == -1 ? NAN : pos;
+    eq->var_values[VAR_T]   = TS2T(in->pts, inlink->time_base);
+
+    if (eq->eval_mode == EVAL_MODE_FRAME) {
+        set_gamma(eq);
+        set_contrast(eq);
+        set_brightness(eq);
+        set_saturation(eq);
+    }
+
     for (i = 0; i < desc->nb_components; i++) {
         int w = inlink->w;
         int h = inlink->h;
 
         if (i == 1 || i == 2) {
-            w = FF_CEIL_RSHIFT(w, desc->log2_chroma_w);
-            h = FF_CEIL_RSHIFT(h, desc->log2_chroma_h);
+            w = AV_CEIL_RSHIFT(w, desc->log2_chroma_w);
+            h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
         }
 
         if (eq->param[i].adjust)
@@ -217,11 +296,44 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     av_frame_free(&in);
     return ff_filter_frame(outlink, out);
 }
+
+static inline int set_param(AVExpr **pexpr, const char *args, const char *cmd,
+                            void (*set_fn)(EQContext *eq), AVFilterContext *ctx)
+{
+    EQContext *eq = ctx->priv;
+    int ret;
+    if ((ret = set_expr(pexpr, args, cmd, ctx)) < 0)
+        return ret;
+    if (eq->eval_mode == EVAL_MODE_INIT)
+        set_fn(eq);
+    return 0;
+}
+
+static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
+                           char *res, int res_len, int flags)
+{
+    EQContext *eq = ctx->priv;
+
+#define SET_PARAM(param_name, set_fn_name)                              \
+    if (!strcmp(cmd, #param_name)) return set_param(&eq->param_name##_pexpr, args, cmd, set_##set_fn_name, ctx);
+
+         SET_PARAM(contrast, contrast)
+    else SET_PARAM(brightness, brightness)
+    else SET_PARAM(saturation, saturation)
+    else SET_PARAM(gamma, gamma)
+    else SET_PARAM(gamma_r, gamma)
+    else SET_PARAM(gamma_g, gamma)
+    else SET_PARAM(gamma_b, gamma)
+    else SET_PARAM(gamma_weight, gamma)
+    else return AVERROR(ENOSYS);
+}
+
 static const AVFilterPad eq_inputs[] = {
     {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
+        .config_props = config_props,
     },
     { NULL }
 };
@@ -239,33 +351,39 @@ static const AVFilterPad eq_outputs[] = {
 
 static const AVOption eq_options[] = {
     { "contrast",     "set the contrast adjustment, negative values give a negative image",
-        OFFSET(contrast),     AV_OPT_TYPE_DOUBLE, {.dbl = 1.0}, -2.0, 2.0, FLAGS },
+        OFFSET(contrast_expr),     AV_OPT_TYPE_STRING, {.str = "1.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "brightness",   "set the brightness adjustment",
-        OFFSET(brightness),   AV_OPT_TYPE_DOUBLE, {.dbl = 0.0}, -1.0, 1.0, FLAGS },
+        OFFSET(brightness_expr),   AV_OPT_TYPE_STRING, {.str = "0.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "saturation",   "set the saturation adjustment",
-        OFFSET(saturation),   AV_OPT_TYPE_DOUBLE, {.dbl = 1.0},  0.0, 3.0, FLAGS },
+        OFFSET(saturation_expr),   AV_OPT_TYPE_STRING, {.str = "1.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "gamma",        "set the initial gamma value",
-        OFFSET(gamma),        AV_OPT_TYPE_DOUBLE, {.dbl = 1.0},  0.1, 10.0, FLAGS },
+        OFFSET(gamma_expr),        AV_OPT_TYPE_STRING, {.str = "1.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "gamma_r",      "gamma value for red",
-        OFFSET(gamma_r),      AV_OPT_TYPE_DOUBLE, {.dbl = 1.0},  0.1, 10.0, FLAGS },
+        OFFSET(gamma_r_expr),      AV_OPT_TYPE_STRING, {.str = "1.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "gamma_g",      "gamma value for green",
-        OFFSET(gamma_g),      AV_OPT_TYPE_DOUBLE, {.dbl = 1.0},  0.1, 10.0, FLAGS },
+        OFFSET(gamma_g_expr),      AV_OPT_TYPE_STRING, {.str = "1.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "gamma_b",      "gamma value for blue",
-        OFFSET(gamma_b),      AV_OPT_TYPE_DOUBLE, {.dbl = 1.0},  0.1, 10.0, FLAGS },
+        OFFSET(gamma_b_expr),      AV_OPT_TYPE_STRING, {.str = "1.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "gamma_weight", "set the gamma weight which reduces the effect of gamma on bright areas",
-        OFFSET(gamma_weight), AV_OPT_TYPE_DOUBLE, {.dbl = 1.0},  0.0, 1.0, FLAGS },
+        OFFSET(gamma_weight_expr), AV_OPT_TYPE_STRING, {.str = "1.0"}, CHAR_MIN, CHAR_MAX, FLAGS },
+    { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
+         { "init",  "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT},  .flags = FLAGS, .unit = "eval" },
+         { "frame", "eval expressions per-frame",                  0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
     { NULL }
 };
 
 AVFILTER_DEFINE_CLASS(eq);
 
 AVFilter ff_vf_eq = {
-    .name          = "eq",
-    .description   = NULL_IF_CONFIG_SMALL("Adjust brightness, contrast, gamma, and saturation."),
-    .priv_size     = sizeof(EQContext),
-    .priv_class    = &eq_class,
-    .inputs        = eq_inputs,
-    .outputs       = eq_outputs,
-    .query_formats = query_formats,
-    .init          = initialize,
+    .name            = "eq",
+    .description     = NULL_IF_CONFIG_SMALL("Adjust brightness, contrast, gamma, and saturation."),
+    .priv_size       = sizeof(EQContext),
+    .priv_class      = &eq_class,
+    .inputs          = eq_inputs,
+    .outputs         = eq_outputs,
+    .process_command = process_command,
+    .query_formats   = query_formats,
+    .init            = initialize,
+    .uninit          = uninit,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };