[FFmpeg-devel] [PATCH] lavfi/hue: add dynamic expression support
Stefano Sabatini
stefasab at gmail.com
Fri Sep 7 11:04:03 CEST 2012
On date Wednesday 2012-09-05 20:00:53 +0200, Jérémy Tran encoded:
> ---
> doc/filters.texi | 20 ++++++
> libavfilter/vf_hue.c | 198 ++++++++++++++++++++++++++++++++++++++-------------
> 2 files changed, 169 insertions(+), 49 deletions(-)
>
> diff --git a/doc/filters.texi b/doc/filters.texi
> index 712936d..0533ca6 100644
> --- a/doc/filters.texi
> +++ b/doc/filters.texi
This is missing the information that the parameters are now
*expressions*, and which are the accepted constants (see how it is
done in crop).
> @@ -2348,6 +2348,26 @@ h and s, so the following example will issue an error:
> @example
> hue=PI/2:1
> @end example
> +
> + at item
> +Set the hue to PI times current time and make the saturation swing between 0
> +and 2:
Rotate hue over a period of 1 second, and ...
> + at example
> +hue="H=2*PI*t: s=sin(2*PI*t)+1"
> + at end example
> +
> + at item
> +3 seconds saturation fade-in:
Apply a 3 seconds saturation fade-in effect:
> + at example
> +hue=s=min(t/3,1)
> + at end example
> +
> + at item
> +3 seconds saturation fade-out at 5 seconds (the general equation is
> +(START+DURATION)/DURATION):
> + at example
> +hue="s=min(1, max(0, min(1, (8-t)/3)))"
> + at end example
I suggest:
Apply a 3 seconds saturation fade-out effect starting at 5 seconds:
@example
hue="s=min(1, max(0, min(1, (8-t)/3)))"
@end example
The general equation is:
@example
...
@end example
Also I think that expression can be simplified, as I suggested in the
previou reply.
> @end itemize
>
> @subsection Commands
> diff --git a/libavfilter/vf_hue.c b/libavfilter/vf_hue.c
> index dd36d8e..0c70006 100644
> --- a/libavfilter/vf_hue.c
> +++ b/libavfilter/vf_hue.c
> @@ -26,6 +26,7 @@
> */
>
> #include <float.h>
> +#include "libavutil/eval.h"
> #include "libavutil/imgutils.h"
> #include "libavutil/opt.h"
> #include "libavutil/pixdesc.h"
> @@ -38,52 +39,126 @@
> #define HUE_DEFAULT_VAL 0
> #define SAT_DEFAULT_VAL 1
>
> +#define SAT_MIN_VAL -10
> +#define SAT_MAX_VAL 10
> +
> +#define CONVERT_HUE_FROM_DEGREES_TO_RADIANS(hue) \
> + do { \
> + hue->hue = hue->hue_deg * M_PI / 180; \
> + } while (0) \
> +
uhm... pointless wrapper?
> typedef struct {
> const AVClass *class;
> float hue_deg; /* hue expressed in degrees */
> float hue; /* hue expressed in radians */
> + char *hue_deg_expr;
> + char *hue_expr;
> + AVExpr *hue_deg_pexpr;
> + AVExpr *hue_pexpr;
> float saturation;
> + char *saturation_expr;
> + AVExpr *saturation_pexpr;
> int hsub;
> int vsub;
> int32_t hue_sin;
> int32_t hue_cos;
> + int flat_syntax;
> } HueContext;
>
> +static const char *const var_names[] = {
> + "t", // timestamp expressed in seconds
> + NULL
> +};
also possibly useful: n (frame count), tb (timebase), pts, and
frame_rate/r when available.
> +enum var_name {
> + VAR_T
> +};
> +
> #define OFFSET(x) offsetof(HueContext, x)
> #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
> static const AVOption hue_options[] = {
> - { "h", "set the hue angle degrees", OFFSET(hue_deg), AV_OPT_TYPE_FLOAT,
> - { -FLT_MAX }, -FLT_MAX, FLT_MAX, FLAGS },
> - { "H", "set the hue angle radians", OFFSET(hue), AV_OPT_TYPE_FLOAT,
> - { -FLT_MAX }, -FLT_MAX, FLT_MAX, FLAGS },
> - { "s", "set the saturation value", OFFSET(saturation), AV_OPT_TYPE_FLOAT,
> - { SAT_DEFAULT_VAL }, -10, 10, FLAGS },
> + { "h", "set the hue angle degrees expression", OFFSET(hue_deg_expr), AV_OPT_TYPE_STRING,
> + { 0 }, .flags = FLAGS },
> + { "H", "set the hue angle radians expression", OFFSET(hue_expr), AV_OPT_TYPE_STRING,
> + { 0 }, .flags = FLAGS },
> + { "s", "set the saturation expression", OFFSET(saturation_expr), AV_OPT_TYPE_STRING,
> + { 0 }, .flags = FLAGS },
It would be possibly be more convenient to set the default expression for
saturation and H (and drop the constant DEFAULT values).
Nit+++: {0} => {.str=NULL} so it is more clear what the function takes
> { NULL }
> };
>
> AVFILTER_DEFINE_CLASS(hue);
>
> +static inline void compute_sin_and_cos(HueContext *hue)
> +{
> + /*
> + * Scale the value to the norm of the resulting (U,V) vector, that is
> + * the saturation.
> + * This will be useful in the process_chrominance function.
> + */
> + hue->hue_sin = rint(sin(hue->hue) * (1 << 16) * hue->saturation);
> + hue->hue_cos = rint(cos(hue->hue) * (1 << 16) * hue->saturation);
> +}
> +
> static inline int set_options(AVFilterContext *ctx, const char *args)
> {
> HueContext *hue = ctx->priv;
> int n, ret;
> char c1 = 0, c2 = 0;
> - char *equal;
> + char *old_hue_expr, *old_hue_deg_expr;
>
> if (args) {
> /* named options syntax */
> - if (equal = strchr(args, '=')) {
> - hue->hue = -FLT_MAX;
> - hue->hue_deg = -FLT_MAX;
> + if (strchr(args, '=')) {
> + old_hue_expr = hue->hue_expr;
> + old_hue_deg_expr = hue->hue_deg_expr;
> + hue->hue_expr = NULL;
> + hue->hue_deg_expr = NULL;
>
> if ((ret = av_set_options_string(hue, args, "=", ":")) < 0)
> return ret;
> - if (hue->hue != -FLT_MAX && hue->hue_deg != -FLT_MAX) {
> + if (hue->hue_expr && hue->hue_deg_expr) {
> av_log(ctx, AV_LOG_ERROR,
> "H and h options are incompatible and cannot be specified "
> "at the same time\n");
> return AVERROR(EINVAL);
> }
> +
> + if (!hue->hue_expr && !hue->hue_deg_expr) {
> + hue->hue_expr = old_hue_expr;
> + hue->hue_deg_expr = old_hue_deg_expr;
> + }
> +
> + if (!hue->hue_expr && !hue->hue_deg_expr) {
> + hue->hue = HUE_DEFAULT_VAL;
These two blocks can be merged.
Also maybe you can avoid hue->hue = HUE_DEFAULT_VAL
> + } else {
> + if (hue->hue_deg_expr) {
> + if ((ret = av_expr_parse(&hue->hue_deg_pexpr, hue->hue_deg_expr, var_names,
> + NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
> + av_log(ctx, AV_LOG_ERROR,
> + "Parsing failed evaluating expression h='%s'\n",
> + hue->hue_deg_expr);
> + return AVERROR(EINVAL);
> + }
> + CONVERT_HUE_FROM_DEGREES_TO_RADIANS(hue);
> + } else if (hue->hue_expr &&
> + (ret = av_expr_parse(&hue->hue_pexpr, hue->hue_expr, var_names,
> + NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
> + av_log(ctx, AV_LOG_ERROR,
> + "Parsing failed evaluating expression H='%s'\n",
> + hue->hue_expr);
> + return AVERROR(EINVAL);
> + }
> + }
> + if (hue->saturation_expr &&
> + (ret = av_expr_parse(&hue->saturation_pexpr, hue->saturation_expr, var_names,
> + NULL, NULL, NULL, NULL, 0, ctx) < 0)) {
> + av_log(ctx, AV_LOG_ERROR,
> + "Parsing failed evaluating expression s='%s'\n",
> + hue->saturation_expr);
> + return AVERROR(EINVAL);
> + }
> +
> + hue->flat_syntax = 0;
> /* compatibility h:s syntax */
> } else {
> n = sscanf(args, "%f%c%f%c", &hue->hue_deg, &c1, &hue->saturation, &c2);
> @@ -94,13 +169,18 @@ static inline int set_options(AVFilterContext *ctx, const char *args)
> return AVERROR(EINVAL);
> }
>
> - if (hue->saturation < -10 || hue->saturation > 10) {
> + if (hue->saturation < SAT_MIN_VAL || hue->saturation > SAT_MAX_VAL) {
> av_log(ctx, AV_LOG_ERROR,
> "Invalid value for saturation %0.1f: "
> - "must be included between range -10 and +10\n", hue->saturation);
> + "must be included between range %d and +%d\n",
> + hue->saturation, SAT_MIN_VAL, SAT_MAX_VAL);
> return AVERROR(EINVAL);
> }
> +
> + CONVERT_HUE_FROM_DEGREES_TO_RADIANS(hue);
> + hue->flat_syntax = 1;
> }
> + compute_sin_and_cos(hue);
> }
>
> return 0;
> @@ -109,25 +189,12 @@ static inline int set_options(AVFilterContext *ctx, const char *args)
> static av_cold int init(AVFilterContext *ctx, const char *args)
> {
> HueContext *hue = ctx->priv;
> - int ret;
>
> hue->class = &hue_class;
> av_opt_set_defaults(hue);
> + hue->saturation = SAT_DEFAULT_VAL;
>
> - if ((ret = set_options(ctx, args)) < 0)
> - return ret;
> -
> - if (hue->saturation == -FLT_MAX)
> - hue->hue = SAT_DEFAULT_VAL;
> - if (hue->hue == -FLT_MAX)
> - hue->hue = HUE_DEFAULT_VAL;
> - if (hue->hue_deg != -FLT_MAX)
> - /* Convert angle from degrees to radians */
> - hue->hue = hue->hue_deg * M_PI / 180;
> -
> - av_log(ctx, AV_LOG_VERBOSE, "hue:%f*PI hue_deg:%f saturation:%f\n",
> - hue->hue/M_PI, hue->hue*180/M_PI, hue->saturation);
> - return 0;
> + return set_options(ctx, args);
> }
>
> static av_cold void uninit(AVFilterContext *ctx)
> @@ -159,13 +226,6 @@ static int config_props(AVFilterLink *inlink)
>
> hue->hsub = desc->log2_chroma_w;
> hue->vsub = desc->log2_chroma_h;
> - /*
> - * Scale the value to the norm of the resulting (U,V) vector, that is
> - * the saturation.
> - * This will be useful in the process_chrominance function.
> - */
> - hue->hue_sin = rint(sin(hue->hue) * (1 << 16) * hue->saturation);
> - hue->hue_cos = rint(cos(hue->hue) * (1 << 16) * hue->saturation);
>
> return 0;
> }
> @@ -209,6 +269,58 @@ static void process_chrominance(uint8_t *udst, uint8_t *vdst, const int dst_line
> }
> }
>
> +static int start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpic)
> +{
> + HueContext *hue = inlink->dst->priv;
> + double var_values[2] = { 0 };
> + AVFilterLink *outlink = inlink->dst->outputs[0];
> + AVFilterBufferRef *buf_out;
> +
> + outlink->out_buf = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
> +
> + if (!outlink->out_buf)
> + return AVERROR(ENOMEM);
Nit+++: drop empty line (so that the set of instructions stand like a
single "visual" block)
> +
> + avfilter_copy_buffer_ref_props(outlink->out_buf, inpic);
> + outlink->out_buf->video->w = outlink->w;
> + outlink->out_buf->video->h = outlink->h;
> + buf_out = avfilter_ref_buffer(outlink->out_buf, ~0);
> +
> + if (!buf_out)
> + return AVERROR(ENOMEM);
Ditto
> +
> + if (!hue->flat_syntax) {
> + var_values[VAR_T] = inpic->pts == AV_NOPTS_VALUE ?
> + NAN : inpic->pts * av_q2d(inlink->time_base);
> +
> + if (hue->saturation_expr) {
> + hue->saturation = av_expr_eval(hue->saturation_pexpr, var_values, NULL);
> +
> + if (hue->saturation < SAT_MIN_VAL || hue->saturation > SAT_MAX_VAL) {
> + hue->saturation = av_clip_c(hue->saturation, -10, 10);
av_clip()
so you're not forced to use the C implementation.
> + av_log(inlink->dst, AV_LOG_WARNING,
> + "Saturation value not in range [%d,%d]: clipping value to %0.1f\n",
> + SAT_MIN_VAL, SAT_MAX_VAL, hue->saturation);
> + }
> + }
> +
> + if (hue->hue_deg_expr) {
> + hue->hue_deg = av_expr_eval(hue->hue_deg_pexpr, var_values, NULL);
> + CONVERT_HUE_FROM_DEGREES_TO_RADIANS(hue);
> + } else if (hue->hue_expr) {
> + hue->hue = av_expr_eval(hue->hue_pexpr, var_values, NULL);
> + }
> +
> + av_log(inlink->dst, AV_LOG_DEBUG,
> + "H:%0.1f, s:%0.f, time:%0.1f",
Nit: more overall consistent: "H:%0.1f s:%0.f t:%0.1f\n",
> + hue->hue, hue->saturation, var_values[VAR_T]);
> +
> + compute_sin_and_cos(hue);
> + }
> +
> + return ff_start_frame(outlink, buf_out);
> +}
> +
> static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
> {
> HueContext *hue = inlink->dst->priv;
> @@ -240,23 +352,10 @@ static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
> static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
> char *res, int res_len, int flags)
> {
> - HueContext *hue = ctx->priv;
> - int ret;
> -
> if (!strcmp(cmd, "reinit")) {
> - if ((ret = set_options(ctx, args)) < 0)
> - return ret;
> -
> - if (hue->hue_deg != -FLT_MAX)
> - /* Convert angle from degrees to radians */
> - hue->hue = hue->hue_deg * M_PI / 180;
> -
> - hue->hue_sin = rint(sin(hue->hue) * (1 << 16) * hue->saturation);
> - hue->hue_cos = rint(cos(hue->hue) * (1 << 16) * hue->saturation);
> + return set_options(ctx, args);
> } else
> return AVERROR(ENOSYS);
> -
> - return 0;
> }
>
> AVFilter avfilter_vf_hue = {
> @@ -274,6 +373,7 @@ AVFilter avfilter_vf_hue = {
> {
> .name = "default",
> .type = AVMEDIA_TYPE_VIDEO,
> + .start_frame = start_frame,
> .draw_slice = draw_slice,
> .config_props = config_props,
> .min_perms = AV_PERM_READ,
Also please make sure that the parameters/expressions are not changed
when they are not explicitly set in process_command().
--
FFmpeg = Furious and Fantastic Merciless Political Egregious Gem
More information about the ffmpeg-devel
mailing list