lavfi/lut3d: restore original interpolation speed.
[ffmpeg.git] / libavfilter / vf_lut3d.c
1 /*
2  * Copyright (c) 2013 Clément Bœsch
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  * 3D Lookup table filter
24  */
25
26 #include "libavutil/opt.h"
27 #include "libavutil/file.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/pixdesc.h"
31 #include "libavutil/avstring.h"
32 #include "avfilter.h"
33 #include "drawutils.h"
34 #include "formats.h"
35 #include "internal.h"
36 #include "video.h"
37
38 #define R 0
39 #define G 1
40 #define B 2
41 #define A 3
42
43 enum interp_mode {
44     INTERPOLATE_NEAREST,
45     INTERPOLATE_TRILINEAR,
46     INTERPOLATE_TETRAHEDRAL,
47     NB_INTERP_MODE
48 };
49
50 struct rgbvec {
51     float r, g, b;
52 };
53
54 #define MAX_LEVEL 36
55
56 typedef struct LUT3DContext {
57     const AVClass *class;
58     enum interp_mode interpolation;
59     char *file;
60     uint8_t rgba_map[4];
61     int step;
62     int is16bit;
63     struct rgbvec (*interp_8) (const struct LUT3DContext*, uint8_t,  uint8_t,  uint8_t);
64     struct rgbvec (*interp_16)(const struct LUT3DContext*, uint16_t, uint16_t, uint16_t);
65     struct rgbvec lut[MAX_LEVEL][MAX_LEVEL][MAX_LEVEL];
66     int lutsize;
67 } LUT3DContext;
68
69 #define OFFSET(x) offsetof(LUT3DContext, x)
70 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
71 static const AVOption lut3d_options[] = {
72     { "file",   "set 3D LUT file name", OFFSET(file), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
73     { "interp", "select interpolation mode", OFFSET(interpolation), AV_OPT_TYPE_INT, {.i64=INTERPOLATE_TETRAHEDRAL}, 0, NB_INTERP_MODE-1, FLAGS, "interp_mode" },
74         { "nearest",     "use values from the nearest defined points",            0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_NEAREST},     INT_MIN, INT_MAX, FLAGS, "interp_mode" },
75         { "trilinear",   "interpolate values using the 8 points defining a cube", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_TRILINEAR},   INT_MIN, INT_MAX, FLAGS, "interp_mode" },
76         { "tetrahedral", "interpolate values using a tetrahedron",                0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_TETRAHEDRAL}, INT_MIN, INT_MAX, FLAGS, "interp_mode" },
77     { NULL }
78 };
79
80 AVFILTER_DEFINE_CLASS(lut3d);
81
82 static inline float lerpf(float v0, float v1, float f)
83 {
84     return v0 + (v1 - v0) * f;
85 }
86
87 static inline struct rgbvec lerp(const struct rgbvec *v0, const struct rgbvec *v1, float f)
88 {
89     struct rgbvec v = {
90         lerpf(v0->r, v1->r, f), lerpf(v0->g, v1->g, f), lerpf(v0->b, v1->b, f)
91     };
92     return v;
93 }
94
95 #define NEAR(x) ((int)((x) + .5))
96 #define PREV(x) ((int)(x))
97 #define NEXT(x) (FFMIN((int)(x) + 1, lut3d->lutsize - 1))
98
99 /**
100  * Get the nearest defined point
101  */
102 static inline struct rgbvec interp_nearest(const LUT3DContext *lut3d,
103                                            const struct rgbvec *s)
104 {
105     return lut3d->lut[NEAR(s->r)][NEAR(s->g)][NEAR(s->b)];
106 }
107
108 /**
109  * Interpolate using the 8 vertices of a cube
110  * @see https://en.wikipedia.org/wiki/Trilinear_interpolation
111  */
112 static inline struct rgbvec interp_trilinear(const LUT3DContext *lut3d,
113                                              const struct rgbvec *s)
114 {
115     const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};
116     const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};
117     const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};
118     const struct rgbvec c000 = lut3d->lut[prev[0]][prev[1]][prev[2]];
119     const struct rgbvec c001 = lut3d->lut[prev[0]][prev[1]][next[2]];
120     const struct rgbvec c010 = lut3d->lut[prev[0]][next[1]][prev[2]];
121     const struct rgbvec c011 = lut3d->lut[prev[0]][next[1]][next[2]];
122     const struct rgbvec c100 = lut3d->lut[next[0]][prev[1]][prev[2]];
123     const struct rgbvec c101 = lut3d->lut[next[0]][prev[1]][next[2]];
124     const struct rgbvec c110 = lut3d->lut[next[0]][next[1]][prev[2]];
125     const struct rgbvec c111 = lut3d->lut[next[0]][next[1]][next[2]];
126     const struct rgbvec c00  = lerp(&c000, &c100, d.r);
127     const struct rgbvec c10  = lerp(&c010, &c110, d.r);
128     const struct rgbvec c01  = lerp(&c001, &c101, d.r);
129     const struct rgbvec c11  = lerp(&c011, &c111, d.r);
130     const struct rgbvec c0   = lerp(&c00,  &c10,  d.g);
131     const struct rgbvec c1   = lerp(&c01,  &c11,  d.g);
132     const struct rgbvec c    = lerp(&c0,   &c1,   d.b);
133     return c;
134 }
135
136 /**
137  * Tetrahedral interpolation. Based on code found in Truelight Software Library paper.
138  * @see http://www.filmlight.ltd.uk/pdf/whitepapers/FL-TL-TN-0057-SoftwareLib.pdf
139  */
140 static inline struct rgbvec interp_tetrahedral(const LUT3DContext *lut3d,
141                                                const struct rgbvec *s)
142 {
143     const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};
144     const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};
145     const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};
146     const struct rgbvec c000 = lut3d->lut[prev[0]][prev[1]][prev[2]];
147     const struct rgbvec c001 = lut3d->lut[prev[0]][prev[1]][next[2]];
148     const struct rgbvec c010 = lut3d->lut[prev[0]][next[1]][prev[2]];
149     const struct rgbvec c011 = lut3d->lut[prev[0]][next[1]][next[2]];
150     const struct rgbvec c100 = lut3d->lut[next[0]][prev[1]][prev[2]];
151     const struct rgbvec c101 = lut3d->lut[next[0]][prev[1]][next[2]];
152     const struct rgbvec c110 = lut3d->lut[next[0]][next[1]][prev[2]];
153     const struct rgbvec c111 = lut3d->lut[next[0]][next[1]][next[2]];
154     struct rgbvec c;
155     if (d.r > d.g) {
156         if (d.g > d.b) {
157             c.r = (1-d.r) * c000.r + (d.r-d.g) * c100.r + (d.g-d.b) * c110.r + (d.b) * c111.r;
158             c.g = (1-d.r) * c000.g + (d.r-d.g) * c100.g + (d.g-d.b) * c110.g + (d.b) * c111.g;
159             c.b = (1-d.r) * c000.b + (d.r-d.g) * c100.b + (d.g-d.b) * c110.b + (d.b) * c111.b;
160         } else if (d.r > d.b) {
161             c.r = (1-d.r) * c000.r + (d.r-d.b) * c100.r + (d.b-d.g) * c101.r + (d.g) * c111.r;
162             c.g = (1-d.r) * c000.g + (d.r-d.b) * c100.g + (d.b-d.g) * c101.g + (d.g) * c111.g;
163             c.b = (1-d.r) * c000.b + (d.r-d.b) * c100.b + (d.b-d.g) * c101.b + (d.g) * c111.b;
164         } else {
165             c.r = (1-d.b) * c000.r + (d.b-d.r) * c001.r + (d.r-d.g) * c101.r + (d.g) * c111.r;
166             c.g = (1-d.b) * c000.g + (d.b-d.r) * c001.g + (d.r-d.g) * c101.g + (d.g) * c111.g;
167             c.b = (1-d.b) * c000.b + (d.b-d.r) * c001.b + (d.r-d.g) * c101.b + (d.g) * c111.b;
168         }
169     } else {
170         if (d.b > d.g) {
171             c.r = (1-d.b) * c000.r + (d.b-d.g) * c001.r + (d.g-d.r) * c011.r + (d.r) * c111.r;
172             c.g = (1-d.b) * c000.g + (d.b-d.g) * c001.g + (d.g-d.r) * c011.g + (d.r) * c111.g;
173             c.b = (1-d.b) * c000.b + (d.b-d.g) * c001.b + (d.g-d.r) * c011.b + (d.r) * c111.b;
174         } else if (d.b > d.r) {
175             c.r = (1-d.g) * c000.r + (d.g-d.b) * c010.r + (d.b-d.r) * c011.r + (d.r) * c111.r;
176             c.g = (1-d.g) * c000.g + (d.g-d.b) * c010.g + (d.b-d.r) * c011.g + (d.r) * c111.g;
177             c.b = (1-d.g) * c000.b + (d.g-d.b) * c010.b + (d.b-d.r) * c011.b + (d.r) * c111.b;
178         } else {
179             c.r = (1-d.g) * c000.r + (d.g-d.r) * c010.r + (d.r-d.b) * c110.r + (d.b) * c111.r;
180             c.g = (1-d.g) * c000.g + (d.g-d.r) * c010.g + (d.r-d.b) * c110.g + (d.b) * c111.g;
181             c.b = (1-d.g) * c000.b + (d.g-d.r) * c010.b + (d.r-d.b) * c110.b + (d.b) * c111.b;
182         }
183     }
184     return c;
185 }
186
187 #define DEFINE_INTERP_FUNC(name, nbits)                                     \
188 static struct rgbvec interp_##nbits##_##name(const LUT3DContext *lut3d,     \
189                                              uint##nbits##_t r,             \
190                                              uint##nbits##_t g,             \
191                                              uint##nbits##_t b)             \
192 {                                                                           \
193     const float scale = (1. / ((1<<nbits) - 1)) * (lut3d->lutsize - 1);     \
194     const struct rgbvec scaled_rgb = {r * scale, g * scale, b * scale};     \
195     return interp_##name(lut3d, &scaled_rgb);                               \
196 }
197
198 DEFINE_INTERP_FUNC(nearest,     8)
199 DEFINE_INTERP_FUNC(trilinear,   8)
200 DEFINE_INTERP_FUNC(tetrahedral, 8)
201
202 DEFINE_INTERP_FUNC(nearest,     16)
203 DEFINE_INTERP_FUNC(trilinear,   16)
204 DEFINE_INTERP_FUNC(tetrahedral, 16)
205
206 #define MAX_LINE_SIZE 512
207
208 static int skip_line(const char *p)
209 {
210     while (*p && av_isspace(*p))
211         p++;
212     return !*p || *p == '#';
213 }
214
215 #define NEXT_LINE(loop_cond) do {                           \
216     if (!fgets(line, sizeof(line), f)) {                    \
217         av_log(ctx, AV_LOG_ERROR, "Unexpected EOF\n");      \
218         return AVERROR_INVALIDDATA;                         \
219     }                                                       \
220 } while (loop_cond)
221
222 /* Basically r g and b float values on each line; seems to be generated by
223  * Davinci */
224 static int parse_dat(AVFilterContext *ctx, FILE *f)
225 {
226     LUT3DContext *lut3d = ctx->priv;
227     const int size = lut3d->lutsize;
228     int i, j, k;
229
230     for (k = 0; k < size; k++) {
231         for (j = 0; j < size; j++) {
232             for (i = 0; i < size; i++) {
233                 char line[MAX_LINE_SIZE];
234                 struct rgbvec *vec = &lut3d->lut[k][j][i];
235                 NEXT_LINE(skip_line(line));
236                 sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b);
237             }
238         }
239     }
240     return 0;
241 }
242
243 /* Iridas format */
244 static int parse_cube(AVFilterContext *ctx, FILE *f)
245 {
246     LUT3DContext *lut3d = ctx->priv;
247     char line[MAX_LINE_SIZE];
248     float min[3] = {0.0, 0.0, 0.0};
249     float max[3] = {1.0, 1.0, 1.0};
250
251     while (fgets(line, sizeof(line), f)) {
252         if (!strncmp(line, "LUT_3D_SIZE ", 12)) {
253             int i, j, k;
254             const int size = strtol(line + 12, NULL, 0);
255
256             if (size > MAX_LEVEL) {
257                 av_log(ctx, AV_LOG_ERROR, "Too large 3D LUT\n");
258                 return AVERROR(EINVAL);
259             }
260             lut3d->lutsize = size;
261             for (k = 0; k < size; k++) {
262                 for (j = 0; j < size; j++) {
263                     for (i = 0; i < size; i++) {
264                         struct rgbvec *vec = &lut3d->lut[k][j][i];
265
266                         do {
267                             NEXT_LINE(0);
268                             if (!strncmp(line, "DOMAIN_", 7)) {
269                                 float *vals = NULL;
270                                 if      (!strncmp(line + 7, "MIN ", 4)) vals = min;
271                                 else if (!strncmp(line + 7, "MAX ", 4)) vals = max;
272                                 if (!vals)
273                                     return AVERROR_INVALIDDATA;
274                                 sscanf(line + 11, "%f %f %f", vals, vals + 1, vals + 2);
275                                 av_log(ctx, AV_LOG_DEBUG, "min: %f %f %f | max: %f %f %f\n",
276                                        min[0], min[1], min[2], max[0], max[1], max[2]);
277                                 continue;
278                             }
279                         } while (skip_line(line));
280                         if (sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3)
281                             return AVERROR_INVALIDDATA;
282                         vec->r *= max[0] - min[0];
283                         vec->g *= max[1] - min[1];
284                         vec->b *= max[2] - min[2];
285                     }
286                 }
287             }
288             break;
289         }
290     }
291     return 0;
292 }
293
294 /* Assume 17x17x17 LUT with a 16-bit depth
295  * FIXME: it seems there are various 3dl formats */
296 static int parse_3dl(AVFilterContext *ctx, FILE *f)
297 {
298     char line[MAX_LINE_SIZE];
299     LUT3DContext *lut3d = ctx->priv;
300     int i, j, k;
301     const int size = 17;
302     const float scale = 16*16*16;
303
304     lut3d->lutsize = size;
305     if (!fgets(line, sizeof(line), f))
306         return AVERROR_INVALIDDATA;
307     for (k = 0; k < size; k++) {
308         for (j = 0; j < size; j++) {
309             for (i = 0; i < size; i++) {
310                 int r, g, b;
311                 struct rgbvec *vec = &lut3d->lut[k][j][i];
312
313                 NEXT_LINE(skip_line(line));
314                 if (sscanf(line, "%d %d %d", &r, &g, &b) != 3)
315                     return AVERROR_INVALIDDATA;
316                 vec->r = r / scale;
317                 vec->g = g / scale;
318                 vec->b = b / scale;
319             }
320         }
321     }
322     return 0;
323 }
324
325 /* Pandora format */
326 static int parse_m3d(AVFilterContext *ctx, FILE *f)
327 {
328     LUT3DContext *lut3d = ctx->priv;
329     float scale;
330     int i, j, k, size, in = -1, out = -1;
331     char line[MAX_LINE_SIZE];
332     uint8_t rgb_map[3] = {0, 1, 2};
333
334     while (fgets(line, sizeof(line), f)) {
335         if      (!strncmp(line, "in",  2)) in  = strtol(line + 2, NULL, 0);
336         else if (!strncmp(line, "out", 3)) out = strtol(line + 3, NULL, 0);
337         else if (!strncmp(line, "values", 6)) {
338             const char *p = line + 6;
339 #define SET_COLOR(id) do {                  \
340     while (av_isspace(*p))                  \
341         p++;                                \
342     switch (*p) {                           \
343     case 'r': rgb_map[id] = 0; break;       \
344     case 'g': rgb_map[id] = 1; break;       \
345     case 'b': rgb_map[id] = 2; break;       \
346     }                                       \
347     while (*p && !av_isspace(*p))           \
348         p++;                                \
349 } while (0)
350             SET_COLOR(0);
351             SET_COLOR(1);
352             SET_COLOR(2);
353             break;
354         }
355     }
356
357     if (in == -1 || out == -1) {
358         av_log(ctx, AV_LOG_ERROR, "in and out must be defined\n");
359         return AVERROR_INVALIDDATA;
360     }
361     for (size = 1; size*size*size < in; size++);
362     lut3d->lutsize = size;
363     scale = 1. / (out - 1);
364
365     for (k = 0; k < size; k++) {
366         for (j = 0; j < size; j++) {
367             for (i = 0; i < size; i++) {
368                 struct rgbvec *vec = &lut3d->lut[k][j][i];
369                 float val[3];
370
371                 NEXT_LINE(0);
372                 if (sscanf(line, "%f %f %f", val, val + 1, val + 2) != 3)
373                     return AVERROR_INVALIDDATA;
374                 vec->r = val[rgb_map[0]] * scale;
375                 vec->g = val[rgb_map[1]] * scale;
376                 vec->b = val[rgb_map[2]] * scale;
377             }
378         }
379     }
380     return 0;
381 }
382
383 static void set_identity_matrix(LUT3DContext *lut3d, int size)
384 {
385     int i, j, k;
386     const float c = 1. / (size - 1);
387
388     lut3d->lutsize = size;
389     for (k = 0; k < size; k++) {
390         for (j = 0; j < size; j++) {
391             for (i = 0; i < size; i++) {
392                 struct rgbvec *vec = &lut3d->lut[k][j][i];
393                 vec->r = k * c;
394                 vec->g = j * c;
395                 vec->b = i * c;
396             }
397         }
398     }
399 }
400
401 static av_cold int init(AVFilterContext *ctx)
402 {
403     int ret;
404     FILE *f;
405     const char *ext;
406     LUT3DContext *lut3d = ctx->priv;
407
408     if (!lut3d->file) {
409         set_identity_matrix(lut3d, 32);
410         return 0;
411     }
412
413     f = fopen(lut3d->file, "r");
414     if (!f) {
415         ret = AVERROR(errno);
416         av_log(ctx, AV_LOG_ERROR, "%s: %s\n", lut3d->file, av_err2str(ret));
417         return ret;
418     }
419
420     ext = strrchr(lut3d->file, '.');
421     if (!ext) {
422         av_log(ctx, AV_LOG_ERROR, "Unable to guess the format from the extension\n");
423         ret = AVERROR_INVALIDDATA;
424         goto end;
425     }
426     ext++;
427
428     if (!av_strcasecmp(ext, "dat")) {
429         lut3d->lutsize = 33;
430         ret = parse_dat(ctx, f);
431     } else if (!av_strcasecmp(ext, "3dl")) {
432         ret = parse_3dl(ctx, f);
433     } else if (!av_strcasecmp(ext, "cube")) {
434         ret = parse_cube(ctx, f);
435     } else if (!av_strcasecmp(ext, "m3d")) {
436         ret = parse_m3d(ctx, f);
437     } else {
438         av_log(ctx, AV_LOG_ERROR, "Unrecognized '.%s' file type\n", ext);
439         ret = AVERROR(EINVAL);
440     }
441
442     if (!ret && !lut3d->lutsize) {
443         av_log(ctx, AV_LOG_ERROR, "3D LUT is empty\n");
444         ret = AVERROR_INVALIDDATA;
445     }
446
447 end:
448     fclose(f);
449     return ret;
450 }
451
452 static int query_formats(AVFilterContext *ctx)
453 {
454     static const enum AVPixelFormat pix_fmts[] = {
455         AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,
456         AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,
457         AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,
458         AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,
459         AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,
460         AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,
461         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
462         AV_PIX_FMT_NONE
463     };
464     ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
465     return 0;
466 }
467
468 static int config_input(AVFilterLink *inlink)
469 {
470     LUT3DContext *lut3d = inlink->dst->priv;
471     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
472
473     switch (inlink->format) {
474     case AV_PIX_FMT_RGB48:
475     case AV_PIX_FMT_BGR48:
476     case AV_PIX_FMT_RGBA64:
477     case AV_PIX_FMT_BGRA64:
478         lut3d->is16bit = 1;
479     }
480
481     ff_fill_rgba_map(lut3d->rgba_map, inlink->format);
482     lut3d->step = av_get_padded_bits_per_pixel(desc) >> (3 + lut3d->is16bit);
483
484 #define SET_FUNC(name) do {                                     \
485     if (lut3d->is16bit) lut3d->interp_16 = interp_16_##name;    \
486     else                lut3d->interp_8  = interp_8_##name;     \
487 } while (0)
488
489     switch (lut3d->interpolation) {
490     case INTERPOLATE_NEAREST:     SET_FUNC(nearest);        break;
491     case INTERPOLATE_TRILINEAR:   SET_FUNC(trilinear);      break;
492     case INTERPOLATE_TETRAHEDRAL: SET_FUNC(tetrahedral);    break;
493     default:
494         av_assert0(0);
495     }
496
497     return 0;
498 }
499
500 #define FILTER(nbits) do {                                                                          \
501     uint8_t       *dstrow = out->data[0];                                                           \
502     const uint8_t *srcrow = in ->data[0];                                                           \
503                                                                                                     \
504     for (y = 0; y < inlink->h; y++) {                                                               \
505         uint##nbits##_t *dst = (uint##nbits##_t *)dstrow;                                           \
506         const uint##nbits##_t *src = (const uint##nbits##_t *)srcrow;                               \
507         for (x = 0; x < inlink->w * step; x += step) {                                              \
508             struct rgbvec vec = lut3d->interp_##nbits(lut3d, src[x + r], src[x + g], src[x + b]);   \
509             dst[x + r] = av_clip_uint##nbits(vec.r * (float)((1<<nbits) - 1));                      \
510             dst[x + g] = av_clip_uint##nbits(vec.g * (float)((1<<nbits) - 1));                      \
511             dst[x + b] = av_clip_uint##nbits(vec.b * (float)((1<<nbits) - 1));                      \
512             if (!direct && step == 4)                                                               \
513                 dst[x + a] = src[x + a];                                                            \
514         }                                                                                           \
515         dstrow += out->linesize[0];                                                                 \
516         srcrow += in ->linesize[0];                                                                 \
517     }                                                                                               \
518 } while (0)
519
520 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
521 {
522     int x, y, direct = 0;
523     AVFilterContext *ctx = inlink->dst;
524     LUT3DContext *lut3d = ctx->priv;
525     AVFilterLink *outlink = inlink->dst->outputs[0];
526     AVFrame *out;
527     const int step = lut3d->step;
528     const uint8_t r = lut3d->rgba_map[R];
529     const uint8_t g = lut3d->rgba_map[G];
530     const uint8_t b = lut3d->rgba_map[B];
531     const uint8_t a = lut3d->rgba_map[A];
532
533     if (av_frame_is_writable(in)) {
534         direct = 1;
535         out = in;
536     } else {
537         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
538         if (!out) {
539             av_frame_free(&in);
540             return AVERROR(ENOMEM);
541         }
542         av_frame_copy_props(out, in);
543     }
544
545     if (lut3d->is16bit) FILTER(16);
546     else                FILTER(8);
547
548     if (!direct)
549         av_frame_free(&in);
550
551     return ff_filter_frame(outlink, out);
552 }
553
554 static const AVFilterPad lut3d_inputs[] = {
555     {
556         .name         = "default",
557         .type         = AVMEDIA_TYPE_VIDEO,
558         .filter_frame = filter_frame,
559         .config_props = config_input,
560     },
561     { NULL }
562 };
563
564 static const AVFilterPad lut3d_outputs[] = {
565      {
566          .name = "default",
567          .type = AVMEDIA_TYPE_VIDEO,
568      },
569      { NULL }
570 };
571
572 AVFilter avfilter_vf_lut3d = {
573     .name          = "lut3d",
574     .description   = NULL_IF_CONFIG_SMALL("Adjust colors using a 3D LUT."),
575     .priv_size     = sizeof(LUT3DContext),
576     .init          = init,
577     .query_formats = query_formats,
578     .inputs        = lut3d_inputs,
579     .outputs       = lut3d_outputs,
580     .priv_class    = &lut3d_class,
581     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
582 };