avfilter/vf_lut: >8 bit depth planar yuv support
[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 LutContext {
61     const AVClass *class;
62     uint16_t lut[4][256 * 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 is_16bit;
69     int step;
70     int negate_alpha; /* only used by negate */
71 } LutContext;
72
73 #define Y 0
74 #define U 1
75 #define V 2
76 #define R 0
77 #define G 1
78 #define B 2
79 #define A 3
80
81 #define OFFSET(x) offsetof(LutContext, x)
82 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
83
84 static const AVOption options[] = {
85     { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
86     { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
87     { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
88     { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
89     { "y",  "set Y expression",            OFFSET(comp_expr_str[Y]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
90     { "u",  "set U expression",            OFFSET(comp_expr_str[U]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
91     { "v",  "set V expression",            OFFSET(comp_expr_str[V]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
92     { "r",  "set R expression",            OFFSET(comp_expr_str[R]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
93     { "g",  "set G expression",            OFFSET(comp_expr_str[G]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
94     { "b",  "set B expression",            OFFSET(comp_expr_str[B]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
95     { "a",  "set A expression",            OFFSET(comp_expr_str[A]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
96     { NULL }
97 };
98
99 static av_cold void uninit(AVFilterContext *ctx)
100 {
101     LutContext *s = ctx->priv;
102     int i;
103
104     for (i = 0; i < 4; i++) {
105         av_expr_free(s->comp_expr[i]);
106         s->comp_expr[i] = NULL;
107         av_freep(&s->comp_expr_str[i]);
108     }
109 }
110
111 #define YUV_FORMATS                                         \
112     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,    \
113     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,    \
114     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,   \
115     AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,   \
116     AV_PIX_FMT_YUVJ440P,                                             \
117     AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUV422P9LE, AV_PIX_FMT_YUV420P9, \
118     AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUV440P10LE, \
119     AV_PIX_FMT_YUV444P12LE, AV_PIX_FMT_YUV422P12LE, AV_PIX_FMT_YUV420P12LE, AV_PIX_FMT_YUV440P12LE, \
120     AV_PIX_FMT_YUV444P14LE, AV_PIX_FMT_YUV422P14LE, AV_PIX_FMT_YUV420P14LE, \
121     AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUV422P16LE, AV_PIX_FMT_YUV420P16LE, \
122     AV_PIX_FMT_YUVA444P16LE, AV_PIX_FMT_YUVA422P16LE, AV_PIX_FMT_YUVA420P16LE
123
124 #define RGB_FORMATS                             \
125     AV_PIX_FMT_ARGB,         AV_PIX_FMT_RGBA,         \
126     AV_PIX_FMT_ABGR,         AV_PIX_FMT_BGRA,         \
127     AV_PIX_FMT_RGB24,        AV_PIX_FMT_BGR24
128
129 static const enum AVPixelFormat yuv_pix_fmts[] = { YUV_FORMATS, AV_PIX_FMT_NONE };
130 static const enum AVPixelFormat rgb_pix_fmts[] = { RGB_FORMATS, AV_PIX_FMT_NONE };
131 static const enum AVPixelFormat all_pix_fmts[] = { RGB_FORMATS, YUV_FORMATS, AV_PIX_FMT_NONE };
132
133 static int query_formats(AVFilterContext *ctx)
134 {
135     LutContext *s = ctx->priv;
136
137     const enum AVPixelFormat *pix_fmts = s->is_rgb ? rgb_pix_fmts :
138                                                      s->is_yuv ? yuv_pix_fmts :
139                                                                  all_pix_fmts;
140     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
141     if (!fmts_list)
142         return AVERROR(ENOMEM);
143     return ff_set_common_formats(ctx, fmts_list);
144 }
145
146 /**
147  * Clip value val in the minval - maxval range.
148  */
149 static double clip(void *opaque, double val)
150 {
151     LutContext *s = opaque;
152     double minval = s->var_values[VAR_MINVAL];
153     double maxval = s->var_values[VAR_MAXVAL];
154
155     return av_clip(val, minval, maxval);
156 }
157
158 /**
159  * Compute gamma correction for value val, assuming the minval-maxval
160  * range, val is clipped to a value contained in the same interval.
161  */
162 static double compute_gammaval(void *opaque, double gamma)
163 {
164     LutContext *s = opaque;
165     double val    = s->var_values[VAR_CLIPVAL];
166     double minval = s->var_values[VAR_MINVAL];
167     double maxval = s->var_values[VAR_MAXVAL];
168
169     return pow((val-minval)/(maxval-minval), gamma) * (maxval-minval)+minval;
170 }
171
172 /**
173  * Compute ITU Rec.709 gamma correction of value val.
174  */
175 static double compute_gammaval709(void *opaque, double gamma)
176 {
177     LutContext *s = opaque;
178     double val    = s->var_values[VAR_CLIPVAL];
179     double minval = s->var_values[VAR_MINVAL];
180     double maxval = s->var_values[VAR_MAXVAL];
181     double level = (val - minval) / (maxval - minval);
182     level = level < 0.018 ? 4.5 * level
183                           : 1.099 * pow(level, 1.0 / gamma) - 0.099;
184     return level * (maxval - minval) + minval;
185 }
186
187 static double (* const funcs1[])(void *, double) = {
188     (void *)clip,
189     (void *)compute_gammaval,
190     (void *)compute_gammaval709,
191     NULL
192 };
193
194 static const char * const funcs1_names[] = {
195     "clip",
196     "gammaval",
197     "gammaval709",
198     NULL
199 };
200
201 static int config_props(AVFilterLink *inlink)
202 {
203     AVFilterContext *ctx = inlink->dst;
204     LutContext *s = ctx->priv;
205     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
206     uint8_t rgba_map[4]; /* component index -> RGBA color index map */
207     int min[4], max[4];
208     int val, color, ret;
209
210     s->hsub = desc->log2_chroma_w;
211     s->vsub = desc->log2_chroma_h;
212
213     s->var_values[VAR_W] = inlink->w;
214     s->var_values[VAR_H] = inlink->h;
215     s->is_16bit = desc->comp[0].depth_minus1 > 7;
216
217     switch (inlink->format) {
218     case AV_PIX_FMT_YUV410P:
219     case AV_PIX_FMT_YUV411P:
220     case AV_PIX_FMT_YUV420P:
221     case AV_PIX_FMT_YUV422P:
222     case AV_PIX_FMT_YUV440P:
223     case AV_PIX_FMT_YUV444P:
224     case AV_PIX_FMT_YUVA420P:
225     case AV_PIX_FMT_YUVA422P:
226     case AV_PIX_FMT_YUVA444P:
227     case AV_PIX_FMT_YUV420P9LE:
228     case AV_PIX_FMT_YUV422P9LE:
229     case AV_PIX_FMT_YUV444P9LE:
230     case AV_PIX_FMT_YUVA420P9LE:
231     case AV_PIX_FMT_YUVA422P9LE:
232     case AV_PIX_FMT_YUVA444P9LE:
233     case AV_PIX_FMT_YUV420P10LE:
234     case AV_PIX_FMT_YUV422P10LE:
235     case AV_PIX_FMT_YUV440P10LE:
236     case AV_PIX_FMT_YUV444P10LE:
237     case AV_PIX_FMT_YUVA420P10LE:
238     case AV_PIX_FMT_YUVA422P10LE:
239     case AV_PIX_FMT_YUVA444P10LE:
240     case AV_PIX_FMT_YUV420P12LE:
241     case AV_PIX_FMT_YUV422P12LE:
242     case AV_PIX_FMT_YUV440P12LE:
243     case AV_PIX_FMT_YUV444P12LE:
244     case AV_PIX_FMT_YUV420P14LE:
245     case AV_PIX_FMT_YUV422P14LE:
246     case AV_PIX_FMT_YUV444P14LE:
247     case AV_PIX_FMT_YUV420P16LE:
248     case AV_PIX_FMT_YUV422P16LE:
249     case AV_PIX_FMT_YUV444P16LE:
250     case AV_PIX_FMT_YUVA420P16LE:
251     case AV_PIX_FMT_YUVA422P16LE:
252     case AV_PIX_FMT_YUVA444P16LE:
253         min[Y] = 16 * (1 << (desc->comp[0].depth_minus1 - 7));
254         min[U] = 16 * (1 << (desc->comp[1].depth_minus1 - 7));
255         min[V] = 16 * (1 << (desc->comp[2].depth_minus1 - 7));
256         min[A] = 0;
257         max[Y] = 235 * (1 << (desc->comp[0].depth_minus1 - 7));
258         max[U] = 240 * (1 << (desc->comp[1].depth_minus1 - 7));
259         max[V] = 240 * (1 << (desc->comp[2].depth_minus1 - 7));
260         max[A] = (1 << (desc->comp[3].depth_minus1 + 1)) - 1;
261         break;
262     default:
263         min[0] = min[1] = min[2] = min[3] = 0;
264         max[0] = max[1] = max[2] = max[3] = 255;
265     }
266
267     s->is_yuv = s->is_rgb = 0;
268     if      (ff_fmt_is_in(inlink->format, yuv_pix_fmts)) s->is_yuv = 1;
269     else if (ff_fmt_is_in(inlink->format, rgb_pix_fmts)) s->is_rgb = 1;
270
271     if (s->is_rgb) {
272         ff_fill_rgba_map(rgba_map, inlink->format);
273         s->step = av_get_bits_per_pixel(desc) >> 3;
274     }
275
276     for (color = 0; color < desc->nb_components; color++) {
277         double res;
278         int comp = s->is_rgb ? rgba_map[color] : color;
279
280         /* create the parsed expression */
281         av_expr_free(s->comp_expr[color]);
282         s->comp_expr[color] = NULL;
283         ret = av_expr_parse(&s->comp_expr[color], s->comp_expr_str[color],
284                             var_names, funcs1_names, funcs1, NULL, NULL, 0, ctx);
285         if (ret < 0) {
286             av_log(ctx, AV_LOG_ERROR,
287                    "Error when parsing the expression '%s' for the component %d and color %d.\n",
288                    s->comp_expr_str[comp], comp, color);
289             return AVERROR(EINVAL);
290         }
291
292         /* compute the lut */
293         s->var_values[VAR_MAXVAL] = max[color];
294         s->var_values[VAR_MINVAL] = min[color];
295
296         for (val = 0; val < (1 << (desc->comp[0].depth_minus1 + 1)); val++) {
297             s->var_values[VAR_VAL] = val;
298             s->var_values[VAR_CLIPVAL] = av_clip(val, min[color], max[color]);
299             s->var_values[VAR_NEGVAL] =
300                 av_clip(min[color] + max[color] - s->var_values[VAR_VAL],
301                         min[color], max[color]);
302
303             res = av_expr_eval(s->comp_expr[color], s->var_values, s);
304             if (isnan(res)) {
305                 av_log(ctx, AV_LOG_ERROR,
306                        "Error when evaluating the expression '%s' for the value %d for the component %d.\n",
307                        s->comp_expr_str[color], val, comp);
308                 return AVERROR(EINVAL);
309             }
310             s->lut[comp][val] = av_clip((int)res, min[color], max[color]);
311             av_log(ctx, AV_LOG_DEBUG, "val[%d][%d] = %d\n", comp, val, s->lut[comp][val]);
312         }
313     }
314
315     return 0;
316 }
317
318 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
319 {
320     AVFilterContext *ctx = inlink->dst;
321     LutContext *s = ctx->priv;
322     AVFilterLink *outlink = ctx->outputs[0];
323     AVFrame *out;
324     int i, j, plane, direct = 0;
325
326     if (av_frame_is_writable(in)) {
327         direct = 1;
328         out = in;
329     } else {
330         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
331         if (!out) {
332             av_frame_free(&in);
333             return AVERROR(ENOMEM);
334         }
335         av_frame_copy_props(out, in);
336     }
337
338     if (s->is_rgb) {
339         /* packed */
340         uint8_t *inrow, *outrow, *inrow0, *outrow0;
341         const int w = inlink->w;
342         const int h = in->height;
343         const uint16_t (*tab)[256*256] = (const uint16_t (*)[256*256])s->lut;
344         const int in_linesize  =  in->linesize[0];
345         const int out_linesize = out->linesize[0];
346         const int step = s->step;
347
348         inrow0  = in ->data[0];
349         outrow0 = out->data[0];
350
351         for (i = 0; i < h; i ++) {
352             inrow  = inrow0;
353             outrow = outrow0;
354             for (j = 0; j < w; j++) {
355                 switch (step) {
356                 case 4:  outrow[3] = tab[3][inrow[3]]; // Fall-through
357                 case 3:  outrow[2] = tab[2][inrow[2]]; // Fall-through
358                 case 2:  outrow[1] = tab[1][inrow[1]]; // Fall-through
359                 default: outrow[0] = tab[0][inrow[0]];
360                 }
361                 outrow += step;
362                 inrow  += step;
363             }
364             inrow0  += in_linesize;
365             outrow0 += out_linesize;
366         }
367     } else if (s->is_16bit) {
368         // planar yuv >8 bit depth
369         uint16_t *inrow, *outrow;
370
371         for (plane = 0; plane < 4 && in->data[plane] && in->linesize[plane]; plane++) {
372             int vsub = plane == 1 || plane == 2 ? s->vsub : 0;
373             int hsub = plane == 1 || plane == 2 ? s->hsub : 0;
374             int h = FF_CEIL_RSHIFT(inlink->h, vsub);
375             int w = FF_CEIL_RSHIFT(inlink->w, hsub);
376             const uint16_t *tab = s->lut[plane];
377             const int in_linesize  =  in->linesize[plane] / 2;
378             const int out_linesize = out->linesize[plane] / 2;
379
380             inrow  = (uint16_t *)in ->data[plane];
381             outrow = (uint16_t *)out->data[plane];
382
383             for (i = 0; i < h; i++) {
384                 for (j = 0; j < w; j++) {
385 #if HAVE_BIGENDIAN
386                     outrow[j] = av_bswap16(tab[av_bswap16(inrow[j])]);
387 #else
388                     outrow[j] = tab[inrow[j]];
389 #endif
390                 }
391                 inrow  += in_linesize;
392                 outrow += out_linesize;
393             }
394         }
395     } else {
396         /* planar 8bit depth */
397         uint8_t *inrow, *outrow;
398
399         for (plane = 0; plane < 4 && in->data[plane] && in->linesize[plane]; plane++) {
400             int vsub = plane == 1 || plane == 2 ? s->vsub : 0;
401             int hsub = plane == 1 || plane == 2 ? s->hsub : 0;
402             int h = FF_CEIL_RSHIFT(inlink->h, vsub);
403             int w = FF_CEIL_RSHIFT(inlink->w, hsub);
404             const uint16_t *tab = s->lut[plane];
405             const int in_linesize  =  in->linesize[plane];
406             const int out_linesize = out->linesize[plane];
407
408             inrow  = in ->data[plane];
409             outrow = out->data[plane];
410
411             for (i = 0; i < h; i++) {
412                 for (j = 0; j < w; j++)
413                     outrow[j] = tab[inrow[j]];
414                 inrow  += in_linesize;
415                 outrow += out_linesize;
416             }
417         }
418     }
419
420     if (!direct)
421         av_frame_free(&in);
422
423     return ff_filter_frame(outlink, out);
424 }
425
426 static const AVFilterPad inputs[] = {
427     { .name         = "default",
428       .type         = AVMEDIA_TYPE_VIDEO,
429       .filter_frame = filter_frame,
430       .config_props = config_props,
431     },
432     { NULL }
433 };
434 static const AVFilterPad outputs[] = {
435     { .name = "default",
436       .type = AVMEDIA_TYPE_VIDEO,
437     },
438     { NULL }
439 };
440
441 #define DEFINE_LUT_FILTER(name_, description_)                          \
442     AVFilter ff_vf_##name_ = {                                          \
443         .name          = #name_,                                        \
444         .description   = NULL_IF_CONFIG_SMALL(description_),            \
445         .priv_size     = sizeof(LutContext),                            \
446         .priv_class    = &name_ ## _class,                              \
447         .init          = name_##_init,                                  \
448         .uninit        = uninit,                                        \
449         .query_formats = query_formats,                                 \
450         .inputs        = inputs,                                        \
451         .outputs       = outputs,                                       \
452         .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,        \
453     }
454
455 #if CONFIG_LUT_FILTER
456
457 #define lut_options options
458 AVFILTER_DEFINE_CLASS(lut);
459
460 static int lut_init(AVFilterContext *ctx)
461 {
462     return 0;
463 }
464
465 DEFINE_LUT_FILTER(lut, "Compute and apply a lookup table to the RGB/YUV input video.");
466 #endif
467
468 #if CONFIG_LUTYUV_FILTER
469
470 #define lutyuv_options options
471 AVFILTER_DEFINE_CLASS(lutyuv);
472
473 static av_cold int lutyuv_init(AVFilterContext *ctx)
474 {
475     LutContext *s = ctx->priv;
476
477     s->is_yuv = 1;
478
479     return 0;
480 }
481
482 DEFINE_LUT_FILTER(lutyuv, "Compute and apply a lookup table to the YUV input video.");
483 #endif
484
485 #if CONFIG_LUTRGB_FILTER
486
487 #define lutrgb_options options
488 AVFILTER_DEFINE_CLASS(lutrgb);
489
490 static av_cold int lutrgb_init(AVFilterContext *ctx)
491 {
492     LutContext *s = ctx->priv;
493
494     s->is_rgb = 1;
495
496     return 0;
497 }
498
499 DEFINE_LUT_FILTER(lutrgb, "Compute and apply a lookup table to the RGB input video.");
500 #endif
501
502 #if CONFIG_NEGATE_FILTER
503
504 static const AVOption negate_options[] = {
505     { "negate_alpha", NULL, OFFSET(negate_alpha), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
506     { NULL }
507 };
508
509 AVFILTER_DEFINE_CLASS(negate);
510
511 static av_cold int negate_init(AVFilterContext *ctx)
512 {
513     LutContext *s = ctx->priv;
514     int i;
515
516     av_log(ctx, AV_LOG_DEBUG, "negate_alpha:%d\n", s->negate_alpha);
517
518     for (i = 0; i < 4; i++) {
519         s->comp_expr_str[i] = av_strdup((i == 3 && !s->negate_alpha) ?
520                                           "val" : "negval");
521         if (!s->comp_expr_str[i]) {
522             uninit(ctx);
523             return AVERROR(ENOMEM);
524         }
525     }
526
527     return 0;
528 }
529
530 DEFINE_LUT_FILTER(negate, "Negate input video.");
531
532 #endif