lavfi/hue: use lookup tables
[ffmpeg.git] / libavfilter / vf_hue.c
1 /*
2  * Copyright (c) 2003 Michael Niedermayer
3  * Copyright (c) 2012 Jeremy Tran
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21
22 /**
23  * @file
24  * Apply a hue/saturation filter to the input video
25  * Ported from MPlayer libmpcodecs/vf_hue.c.
26  */
27
28 #include <float.h>
29 #include "libavutil/eval.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33
34 #include "avfilter.h"
35 #include "formats.h"
36 #include "internal.h"
37 #include "video.h"
38
39 #define SAT_MIN_VAL -10
40 #define SAT_MAX_VAL 10
41
42 static const char *const var_names[] = {
43     "n",   // frame count
44     "pts", // presentation timestamp expressed in AV_TIME_BASE units
45     "r",   // frame rate
46     "t",   // timestamp expressed in seconds
47     "tb",  // timebase
48     NULL
49 };
50
51 enum var_name {
52     VAR_N,
53     VAR_PTS,
54     VAR_R,
55     VAR_T,
56     VAR_TB,
57     VAR_NB
58 };
59
60 typedef struct {
61     const    AVClass *class;
62     float    hue_deg; /* hue expressed in degrees */
63     float    hue; /* hue expressed in radians */
64     char     *hue_deg_expr;
65     char     *hue_expr;
66     AVExpr   *hue_deg_pexpr;
67     AVExpr   *hue_pexpr;
68     float    saturation;
69     char     *saturation_expr;
70     AVExpr   *saturation_pexpr;
71     int      hsub;
72     int      vsub;
73     int32_t hue_sin;
74     int32_t hue_cos;
75     double   var_values[VAR_NB];
76     uint8_t  lut_u[256][256];
77     uint8_t  lut_v[256][256];
78 } HueContext;
79
80 #define OFFSET(x) offsetof(HueContext, x)
81 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
82 static const AVOption hue_options[] = {
83     { "h", "set the hue angle degrees expression", OFFSET(hue_deg_expr), AV_OPT_TYPE_STRING,
84       { .str = NULL }, .flags = FLAGS },
85     { "s", "set the saturation expression", OFFSET(saturation_expr), AV_OPT_TYPE_STRING,
86       { .str = "1" }, .flags = FLAGS },
87     { "H", "set the hue angle radians expression", OFFSET(hue_expr), AV_OPT_TYPE_STRING,
88       { .str = NULL }, .flags = FLAGS },
89     { NULL }
90 };
91
92 AVFILTER_DEFINE_CLASS(hue);
93
94 static inline void compute_sin_and_cos(HueContext *hue)
95 {
96     /*
97      * Scale the value to the norm of the resulting (U,V) vector, that is
98      * the saturation.
99      * This will be useful in the apply_lut function.
100      */
101     hue->hue_sin = rint(sin(hue->hue) * (1 << 16) * hue->saturation);
102     hue->hue_cos = rint(cos(hue->hue) * (1 << 16) * hue->saturation);
103 }
104
105 static inline void create_chrominance_lut(HueContext *h, const int32_t c,
106                                           const int32_t s)
107 {
108     int32_t i, j, u, v, new_u, new_v;
109
110     /*
111      * If we consider U and V as the components of a 2D vector then its angle
112      * is the hue and the norm is the saturation
113      */
114     for (i = 0; i < 256; i++) {
115         for (j = 0; j < 256; j++) {
116             /* Normalize the components from range [16;140] to [-112;112] */
117             u = i - 128;
118             v = j - 128;
119             /*
120              * Apply the rotation of the vector : (c * u) - (s * v)
121              *                                    (s * u) + (c * v)
122              * De-normalize the components (without forgetting to scale 128
123              * by << 16)
124              * Finally scale back the result by >> 16
125              */
126             new_u = ((c * u) - (s * v) + (1 << 15) + (128 << 16)) >> 16;
127             new_v = ((s * u) + (c * v) + (1 << 15) + (128 << 16)) >> 16;
128
129             /* Prevent a potential overflow */
130             h->lut_u[i][j] = av_clip_uint8_c(new_u);
131             h->lut_v[i][j] = av_clip_uint8_c(new_v);
132         }
133     }
134 }
135
136 static int set_expr(AVExpr **pexpr_ptr, char **expr_ptr,
137                     const char *expr, const char *option, void *log_ctx)
138 {
139     int ret;
140     AVExpr *new_pexpr;
141     char *new_expr;
142
143     new_expr = av_strdup(expr);
144     if (!new_expr)
145         return AVERROR(ENOMEM);
146     ret = av_expr_parse(&new_pexpr, expr, var_names,
147                         NULL, NULL, NULL, NULL, 0, log_ctx);
148     if (ret < 0) {
149         av_log(log_ctx, AV_LOG_ERROR,
150                "Error when evaluating the expression '%s' for %s\n",
151                expr, option);
152         av_free(new_expr);
153         return ret;
154     }
155
156     if (*pexpr_ptr)
157         av_expr_free(*pexpr_ptr);
158     *pexpr_ptr = new_pexpr;
159     av_freep(expr_ptr);
160     *expr_ptr = new_expr;
161
162     return 0;
163 }
164
165 static av_cold int init(AVFilterContext *ctx)
166 {
167     HueContext *hue = ctx->priv;
168     int ret;
169
170     if (hue->hue_expr && hue->hue_deg_expr) {
171         av_log(ctx, AV_LOG_ERROR,
172                "H and h options are incompatible and cannot be specified "
173                "at the same time\n");
174         return AVERROR(EINVAL);
175     }
176
177 #define SET_EXPR(expr, option)                                          \
178     if (hue->expr##_expr) do {                                          \
179         ret = set_expr(&hue->expr##_pexpr, &hue->expr##_expr,           \
180                        hue->expr##_expr, option, ctx);                  \
181         if (ret < 0)                                                    \
182             return ret;                                                 \
183     } while (0)
184     SET_EXPR(saturation, "s");
185     SET_EXPR(hue_deg,    "h");
186     SET_EXPR(hue,        "H");
187 #undef SET_EXPR
188
189     av_log(ctx, AV_LOG_VERBOSE,
190            "H_expr:%s h_deg_expr:%s s_expr:%s\n",
191            hue->hue_expr, hue->hue_deg_expr, hue->saturation_expr);
192     compute_sin_and_cos(hue);
193
194     return 0;
195 }
196
197 static av_cold void uninit(AVFilterContext *ctx)
198 {
199     HueContext *hue = ctx->priv;
200
201     av_expr_free(hue->hue_deg_pexpr);
202     av_expr_free(hue->hue_pexpr);
203     av_expr_free(hue->saturation_pexpr);
204 }
205
206 static int query_formats(AVFilterContext *ctx)
207 {
208     static const enum AVPixelFormat pix_fmts[] = {
209         AV_PIX_FMT_YUV444P,      AV_PIX_FMT_YUV422P,
210         AV_PIX_FMT_YUV420P,      AV_PIX_FMT_YUV411P,
211         AV_PIX_FMT_YUV410P,      AV_PIX_FMT_YUV440P,
212         AV_PIX_FMT_YUVA444P,     AV_PIX_FMT_YUVA422P,
213         AV_PIX_FMT_YUVA420P,
214         AV_PIX_FMT_NONE
215     };
216
217     ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
218
219     return 0;
220 }
221
222 static int config_props(AVFilterLink *inlink)
223 {
224     HueContext *hue = inlink->dst->priv;
225     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
226
227     hue->hsub = desc->log2_chroma_w;
228     hue->vsub = desc->log2_chroma_h;
229
230     hue->var_values[VAR_N]  = 0;
231     hue->var_values[VAR_TB] = av_q2d(inlink->time_base);
232     hue->var_values[VAR_R]  = inlink->frame_rate.num == 0 || inlink->frame_rate.den == 0 ?
233         NAN : av_q2d(inlink->frame_rate);
234
235     return 0;
236 }
237
238 static void apply_lut(HueContext *s,
239                       uint8_t *udst, uint8_t *vdst, const int dst_linesize,
240                       uint8_t *usrc, uint8_t *vsrc, const int src_linesize,
241                       int w, int h)
242 {
243     int i;
244
245     while (h--) {
246         for (i = 0; i < w; i++) {
247             const int u = usrc[i];
248             const int v = vsrc[i];
249
250             udst[i] = s->lut_u[u][v];
251             vdst[i] = s->lut_v[u][v];
252         }
253
254         usrc += src_linesize;
255         vsrc += src_linesize;
256         udst += dst_linesize;
257         vdst += dst_linesize;
258     }
259 }
260
261 #define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts))
262 #define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts) * av_q2d(tb))
263
264 static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
265 {
266     HueContext *hue = inlink->dst->priv;
267     AVFilterLink *outlink = inlink->dst->outputs[0];
268     AVFrame *outpic;
269     const int32_t old_hue_sin = hue->hue_sin, old_hue_cos = hue->hue_cos;
270     int direct = 0;
271
272     if (av_frame_is_writable(inpic)) {
273         direct = 1;
274         outpic = inpic;
275     } else {
276         outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
277         if (!outpic) {
278             av_frame_free(&inpic);
279             return AVERROR(ENOMEM);
280         }
281         av_frame_copy_props(outpic, inpic);
282     }
283
284     hue->var_values[VAR_N]   = inlink->frame_count;
285     hue->var_values[VAR_T]   = TS2T(inpic->pts, inlink->time_base);
286     hue->var_values[VAR_PTS] = TS2D(inpic->pts);
287
288     if (hue->saturation_expr) {
289         hue->saturation = av_expr_eval(hue->saturation_pexpr, hue->var_values, NULL);
290
291         if (hue->saturation < SAT_MIN_VAL || hue->saturation > SAT_MAX_VAL) {
292             hue->saturation = av_clip(hue->saturation, SAT_MIN_VAL, SAT_MAX_VAL);
293             av_log(inlink->dst, AV_LOG_WARNING,
294                    "Saturation value not in range [%d,%d]: clipping value to %0.1f\n",
295                    SAT_MIN_VAL, SAT_MAX_VAL, hue->saturation);
296         }
297     }
298
299     if (hue->hue_deg_expr) {
300         hue->hue_deg = av_expr_eval(hue->hue_deg_pexpr, hue->var_values, NULL);
301         hue->hue = hue->hue_deg * M_PI / 180;
302     } else if (hue->hue_expr) {
303         hue->hue = av_expr_eval(hue->hue_pexpr, hue->var_values, NULL);
304         hue->hue_deg = hue->hue * 180 / M_PI;
305     }
306
307     av_log(inlink->dst, AV_LOG_DEBUG,
308            "H:%0.1f*PI h:%0.1f s:%0.f t:%0.1f n:%d\n",
309            hue->hue/M_PI, hue->hue_deg, hue->saturation,
310            hue->var_values[VAR_T], (int)hue->var_values[VAR_N]);
311
312     compute_sin_and_cos(hue);
313     if (old_hue_sin != hue->hue_sin || old_hue_cos != hue->hue_cos)
314         create_chrominance_lut(hue, hue->hue_cos, hue->hue_sin);
315
316     if (!direct) {
317         av_image_copy_plane(outpic->data[0], outpic->linesize[0],
318                             inpic->data[0],  inpic->linesize[0],
319                             inlink->w, inlink->h);
320         if (inpic->data[3])
321             av_image_copy_plane(outpic->data[3], outpic->linesize[3],
322                                 inpic->data[3],  inpic->linesize[3],
323                                 inlink->w, inlink->h);
324     }
325
326     apply_lut(hue, outpic->data[1], outpic->data[2], outpic->linesize[1],
327               inpic->data[1],  inpic->data[2],  inpic->linesize[1],
328               FF_CEIL_RSHIFT(inlink->w, hue->hsub),
329               FF_CEIL_RSHIFT(inlink->h, hue->vsub));
330
331     if (!direct)
332         av_frame_free(&inpic);
333     return ff_filter_frame(outlink, outpic);
334 }
335
336 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
337                            char *res, int res_len, int flags)
338 {
339     HueContext *hue = ctx->priv;
340     int ret;
341
342 #define SET_EXPR(expr, option)                                          \
343     do {                                                                \
344         ret = set_expr(&hue->expr##_pexpr, &hue->expr##_expr,           \
345                        args, option, ctx);                              \
346         if (ret < 0)                                                    \
347             return ret;                                                 \
348     } while (0)
349
350     if (!strcmp(cmd, "h")) {
351         SET_EXPR(hue_deg, "h");
352         av_freep(&hue->hue_expr);
353     } else if (!strcmp(cmd, "H")) {
354         SET_EXPR(hue, "H");
355         av_freep(&hue->hue_deg_expr);
356     } else if (!strcmp(cmd, "s")) {
357         SET_EXPR(saturation, "s");
358     } else
359         return AVERROR(ENOSYS);
360
361     return 0;
362 }
363
364 static const AVFilterPad hue_inputs[] = {
365     {
366         .name         = "default",
367         .type         = AVMEDIA_TYPE_VIDEO,
368         .filter_frame = filter_frame,
369         .config_props = config_props,
370     },
371     { NULL }
372 };
373
374 static const AVFilterPad hue_outputs[] = {
375     {
376         .name = "default",
377         .type = AVMEDIA_TYPE_VIDEO,
378     },
379     { NULL }
380 };
381
382 AVFilter avfilter_vf_hue = {
383     .name        = "hue",
384     .description = NULL_IF_CONFIG_SMALL("Adjust the hue and saturation of the input video."),
385
386     .priv_size = sizeof(HueContext),
387
388     .init          = init,
389     .uninit        = uninit,
390     .query_formats = query_formats,
391     .process_command = process_command,
392     .inputs          = hue_inputs,
393     .outputs         = hue_outputs,
394     .priv_class      = &hue_class,
395     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
396 };