Merge commit '093804a93cc5da3f95f98265a5df116912443cec'
[ffmpeg.git] / libavfilter / vf_lut.c
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * Compute a look-up table for binding the input value to the output
24  * value, and apply it to input video.
25  */
26
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/eval.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "avfilter.h"
33 #include "drawutils.h"
34 #include "formats.h"
35 #include "internal.h"
36 #include "video.h"
37
38 static const char *const var_names[] = {
39     "w",        ///< width of the input video
40     "h",        ///< height of the input video
41     "val",      ///< input value for the pixel
42     "maxval",   ///< max value for the pixel
43     "minval",   ///< min value for the pixel
44     "negval",   ///< negated value
45     "clipval",
46     NULL
47 };
48
49 enum var_name {
50     VAR_W,
51     VAR_H,
52     VAR_VAL,
53     VAR_MAXVAL,
54     VAR_MINVAL,
55     VAR_NEGVAL,
56     VAR_CLIPVAL,
57     VAR_VARS_NB
58 };
59
60 typedef struct {
61     const AVClass *class;
62     uint8_t lut[4][256];  ///< lookup table for each component
63     char   *comp_expr_str[4];
64     AVExpr *comp_expr[4];
65     int hsub, vsub;
66     double var_values[VAR_VARS_NB];
67     int is_rgb, is_yuv;
68     int step;
69     int negate_alpha; /* only used by negate */
70 } LutContext;
71
72 #define Y 0
73 #define U 1
74 #define V 2
75 #define R 0
76 #define G 1
77 #define B 2
78 #define A 3
79
80 #define OFFSET(x) offsetof(LutContext, x)
81 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
82
83 static const AVOption options[] = {
84     { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
85     { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
86     { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
87     { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
88     { "y",  "set Y expression",            OFFSET(comp_expr_str[Y]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
89     { "u",  "set U expression",            OFFSET(comp_expr_str[U]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
90     { "v",  "set V expression",            OFFSET(comp_expr_str[V]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
91     { "r",  "set R expression",            OFFSET(comp_expr_str[R]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
92     { "g",  "set G expression",            OFFSET(comp_expr_str[G]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
93     { "b",  "set B expression",            OFFSET(comp_expr_str[B]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
94     { "a",  "set A expression",            OFFSET(comp_expr_str[A]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
95     { NULL },
96 };
97
98 static av_cold void uninit(AVFilterContext *ctx)
99 {
100     LutContext *lut = ctx->priv;
101     int i;
102
103     for (i = 0; i < 4; i++) {
104         av_expr_free(lut->comp_expr[i]);
105         lut->comp_expr[i] = NULL;
106         av_freep(&lut->comp_expr_str[i]);
107     }
108 }
109
110 #define YUV_FORMATS                                         \
111     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,    \
112     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,    \
113     AV_PIX_FMT_YUVA420P,                                       \
114     AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,   \
115     AV_PIX_FMT_YUVJ440P
116
117 #define RGB_FORMATS                             \
118     AV_PIX_FMT_ARGB,         AV_PIX_FMT_RGBA,         \
119     AV_PIX_FMT_ABGR,         AV_PIX_FMT_BGRA,         \
120     AV_PIX_FMT_RGB24,        AV_PIX_FMT_BGR24
121
122 static const enum AVPixelFormat yuv_pix_fmts[] = { YUV_FORMATS, AV_PIX_FMT_NONE };
123 static const enum AVPixelFormat rgb_pix_fmts[] = { RGB_FORMATS, AV_PIX_FMT_NONE };
124 static const enum AVPixelFormat all_pix_fmts[] = { RGB_FORMATS, YUV_FORMATS, AV_PIX_FMT_NONE };
125
126 static int query_formats(AVFilterContext *ctx)
127 {
128     LutContext *lut = ctx->priv;
129
130     const enum AVPixelFormat *pix_fmts = lut->is_rgb ? rgb_pix_fmts :
131                                        lut->is_yuv ? yuv_pix_fmts : all_pix_fmts;
132
133     ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
134     return 0;
135 }
136
137 /**
138  * Clip value val in the minval - maxval range.
139  */
140 static double clip(void *opaque, double val)
141 {
142     LutContext *lut = opaque;
143     double minval = lut->var_values[VAR_MINVAL];
144     double maxval = lut->var_values[VAR_MAXVAL];
145
146     return av_clip(val, minval, maxval);
147 }
148
149 /**
150  * Compute gamma correction for value val, assuming the minval-maxval
151  * range, val is clipped to a value contained in the same interval.
152  */
153 static double compute_gammaval(void *opaque, double gamma)
154 {
155     LutContext *lut = opaque;
156     double val    = lut->var_values[VAR_CLIPVAL];
157     double minval = lut->var_values[VAR_MINVAL];
158     double maxval = lut->var_values[VAR_MAXVAL];
159
160     return pow((val-minval)/(maxval-minval), gamma) * (maxval-minval)+minval;
161 }
162
163 static double (* const funcs1[])(void *, double) = {
164     (void *)clip,
165     (void *)compute_gammaval,
166     NULL
167 };
168
169 static const char * const funcs1_names[] = {
170     "clip",
171     "gammaval",
172     NULL
173 };
174
175 static int config_props(AVFilterLink *inlink)
176 {
177     AVFilterContext *ctx = inlink->dst;
178     LutContext *lut = ctx->priv;
179     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
180     uint8_t rgba_map[4]; /* component index -> RGBA color index map */
181     int min[4], max[4];
182     int val, color, ret;
183
184     lut->hsub = desc->log2_chroma_w;
185     lut->vsub = desc->log2_chroma_h;
186
187     lut->var_values[VAR_W] = inlink->w;
188     lut->var_values[VAR_H] = inlink->h;
189
190     switch (inlink->format) {
191     case AV_PIX_FMT_YUV410P:
192     case AV_PIX_FMT_YUV411P:
193     case AV_PIX_FMT_YUV420P:
194     case AV_PIX_FMT_YUV422P:
195     case AV_PIX_FMT_YUV440P:
196     case AV_PIX_FMT_YUV444P:
197     case AV_PIX_FMT_YUVA420P:
198         min[Y] = min[U] = min[V] = 16;
199         max[Y] = 235;
200         max[U] = max[V] = 240;
201         min[A] = 0; max[A] = 255;
202         break;
203     default:
204         min[0] = min[1] = min[2] = min[3] = 0;
205         max[0] = max[1] = max[2] = max[3] = 255;
206     }
207
208     lut->is_yuv = lut->is_rgb = 0;
209     if      (ff_fmt_is_in(inlink->format, yuv_pix_fmts)) lut->is_yuv = 1;
210     else if (ff_fmt_is_in(inlink->format, rgb_pix_fmts)) lut->is_rgb = 1;
211
212     if (lut->is_rgb) {
213         ff_fill_rgba_map(rgba_map, inlink->format);
214         lut->step = av_get_bits_per_pixel(desc) >> 3;
215     }
216
217     for (color = 0; color < desc->nb_components; color++) {
218         double res;
219         int comp = lut->is_rgb ? rgba_map[color] : color;
220
221         /* create the parsed expression */
222         ret = av_expr_parse(&lut->comp_expr[color], lut->comp_expr_str[color],
223                             var_names, funcs1_names, funcs1, NULL, NULL, 0, ctx);
224         if (ret < 0) {
225             av_log(ctx, AV_LOG_ERROR,
226                    "Error when parsing the expression '%s' for the component %d and color %d.\n",
227                    lut->comp_expr_str[comp], comp, color);
228             return AVERROR(EINVAL);
229         }
230
231         /* compute the lut */
232         lut->var_values[VAR_MAXVAL] = max[color];
233         lut->var_values[VAR_MINVAL] = min[color];
234
235         for (val = 0; val < 256; val++) {
236             lut->var_values[VAR_VAL] = val;
237             lut->var_values[VAR_CLIPVAL] = av_clip(val, min[color], max[color]);
238             lut->var_values[VAR_NEGVAL] =
239                 av_clip(min[color] + max[color] - lut->var_values[VAR_VAL],
240                         min[color], max[color]);
241
242             res = av_expr_eval(lut->comp_expr[color], lut->var_values, lut);
243             if (isnan(res)) {
244                 av_log(ctx, AV_LOG_ERROR,
245                        "Error when evaluating the expression '%s' for the value %d for the component %d.\n",
246                        lut->comp_expr_str[color], val, comp);
247                 return AVERROR(EINVAL);
248             }
249             lut->lut[comp][val] = av_clip((int)res, min[color], max[color]);
250             av_log(ctx, AV_LOG_DEBUG, "val[%d][%d] = %d\n", comp, val, lut->lut[comp][val]);
251         }
252     }
253
254     return 0;
255 }
256
257 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
258 {
259     AVFilterContext *ctx = inlink->dst;
260     LutContext *lut = ctx->priv;
261     AVFilterLink *outlink = ctx->outputs[0];
262     AVFrame *out;
263     uint8_t *inrow, *outrow, *inrow0, *outrow0;
264     int i, j, plane, direct = 0;
265
266     if (av_frame_is_writable(in)) {
267         direct = 1;
268         out = in;
269     } else {
270         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
271         if (!out) {
272             av_frame_free(&in);
273             return AVERROR(ENOMEM);
274         }
275         av_frame_copy_props(out, in);
276     }
277
278     if (lut->is_rgb) {
279         /* packed */
280         inrow0  = in ->data[0];
281         outrow0 = out->data[0];
282
283         for (i = 0; i < in->height; i ++) {
284             int w = inlink->w;
285             const uint8_t (*tab)[256] = (const uint8_t (*)[256])lut->lut;
286             inrow  = inrow0;
287             outrow = outrow0;
288             for (j = 0; j < w; j++) {
289                 switch (lut->step) {
290                 case 4:  outrow[3] = tab[3][inrow[3]]; // Fall-through
291                 case 3:  outrow[2] = tab[2][inrow[2]]; // Fall-through
292                 case 2:  outrow[1] = tab[1][inrow[1]]; // Fall-through
293                 default: outrow[0] = tab[0][inrow[0]];
294                 }
295                 outrow += lut->step;
296                 inrow  += lut->step;
297             }
298             inrow0  += in ->linesize[0];
299             outrow0 += out->linesize[0];
300         }
301     } else {
302         /* planar */
303         for (plane = 0; plane < 4 && in->data[plane]; plane++) {
304             int vsub = plane == 1 || plane == 2 ? lut->vsub : 0;
305             int hsub = plane == 1 || plane == 2 ? lut->hsub : 0;
306
307             inrow  = in ->data[plane];
308             outrow = out->data[plane];
309
310             for (i = 0; i < (in->height + (1<<vsub) - 1)>>vsub; i ++) {
311                 const uint8_t *tab = lut->lut[plane];
312                 int w = (inlink->w + (1<<hsub) - 1)>>hsub;
313                 for (j = 0; j < w; j++)
314                     outrow[j] = tab[inrow[j]];
315                 inrow  += in ->linesize[plane];
316                 outrow += out->linesize[plane];
317             }
318         }
319     }
320
321     if (!direct)
322         av_frame_free(&in);
323
324     return ff_filter_frame(outlink, out);
325 }
326
327 static const AVFilterPad inputs[] = {
328     { .name            = "default",
329       .type            = AVMEDIA_TYPE_VIDEO,
330       .filter_frame    = filter_frame,
331       .config_props    = config_props,
332     },
333     { .name = NULL}
334 };
335 static const AVFilterPad outputs[] = {
336     { .name            = "default",
337       .type            = AVMEDIA_TYPE_VIDEO, },
338     { .name = NULL}
339 };
340
341 #define DEFINE_LUT_FILTER(name_, description_)                          \
342     AVFilter avfilter_vf_##name_ = {                                    \
343         .name          = #name_,                                        \
344         .description   = NULL_IF_CONFIG_SMALL(description_),            \
345         .priv_size     = sizeof(LutContext),                            \
346         .priv_class    = &name_ ## _class,                              \
347                                                                         \
348         .init          = name_##_init,                                  \
349         .uninit        = uninit,                                        \
350         .query_formats = query_formats,                                 \
351                                                                         \
352         .inputs        = inputs,                                        \
353         .outputs       = outputs,                                       \
354         .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE,                \
355     }
356
357 #if CONFIG_LUT_FILTER
358
359 #define lut_options options
360 AVFILTER_DEFINE_CLASS(lut);
361
362 static int lut_init(AVFilterContext *ctx)
363 {
364     return 0;
365 }
366
367 DEFINE_LUT_FILTER(lut, "Compute and apply a lookup table to the RGB/YUV input video.");
368 #endif
369
370 #if CONFIG_LUTYUV_FILTER
371
372 #define lutyuv_options options
373 AVFILTER_DEFINE_CLASS(lutyuv);
374
375 static av_cold int lutyuv_init(AVFilterContext *ctx)
376 {
377     LutContext *lut = ctx->priv;
378
379     lut->is_yuv = 1;
380
381     return 0;
382 }
383
384 DEFINE_LUT_FILTER(lutyuv, "Compute and apply a lookup table to the YUV input video.");
385 #endif
386
387 #if CONFIG_LUTRGB_FILTER
388
389 #define lutrgb_options options
390 AVFILTER_DEFINE_CLASS(lutrgb);
391
392 static av_cold int lutrgb_init(AVFilterContext *ctx)
393 {
394     LutContext *lut = ctx->priv;
395
396     lut->is_rgb = 1;
397
398     return 0;
399 }
400
401 DEFINE_LUT_FILTER(lutrgb, "Compute and apply a lookup table to the RGB input video.");
402 #endif
403
404 #if CONFIG_NEGATE_FILTER
405
406 static const AVOption negate_options[] = {
407     { "negate_alpha", NULL, OFFSET(negate_alpha), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
408     { NULL },
409 };
410
411 AVFILTER_DEFINE_CLASS(negate);
412
413 static av_cold int negate_init(AVFilterContext *ctx)
414 {
415     LutContext *lut = ctx->priv;
416     int i;
417
418     av_log(ctx, AV_LOG_DEBUG, "negate_alpha:%d\n", lut->negate_alpha);
419
420     for (i = 0; i < 4; i++) {
421         lut->comp_expr_str[i] = av_strdup((i == 3 && !lut->negate_alpha) ?
422                                           "val" : "negval");
423         if (!lut->comp_expr_str[i]) {
424             uninit(ctx);
425             return AVERROR(ENOMEM);
426         }
427     }
428
429     return 0;
430 }
431
432 DEFINE_LUT_FILTER(negate, "Negate input video.");
433
434 #endif